Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/handlers/calculus.py

@@ -0,0 +1,273 @@
+"""
+This module contains query handlers responsible for calculus queries:
+infinitesimal, finite, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Expr, Add, Mul, Pow, Symbol
+from sympy.core.numbers import (NegativeInfinity, GoldenRatio,
+    Infinity, Exp1, ComplexInfinity, ImaginaryUnit, NaN, Number, Pi, E,
+    TribonacciConstant)
+from sympy.functions import cos, exp, log, sign, sin
+from sympy.logic.boolalg import conjuncts
+
+from ..predicates.calculus import (FinitePredicate, InfinitePredicate,
+    PositiveInfinitePredicate, NegativeInfinitePredicate)
+
+
+# FinitePredicate
+
+
+@FinitePredicate.register(Symbol)
+def _(expr, assumptions):
+    """
+    Handles Symbol.
+    """
+    if expr.is_finite is not None:
+        return expr.is_finite
+    if Q.finite(expr) in conjuncts(assumptions):
+        return True
+    return None
+
+@FinitePredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Return True if expr is bounded, False if not and None if unknown.
+
+    Truth Table:
+
+    +-------+-----+-----------+-----------+
+    |       |     |           |           |
+    |       |  B  |     U     |     ?     |
+    |       |     |           |           |
+    +-------+-----+---+---+---+---+---+---+
+    |       |     |   |   |   |   |   |   |
+    |       |     |'+'|'-'|'x'|'+'|'-'|'x'|
+    |       |     |   |   |   |   |   |   |
+    +-------+-----+---+---+---+---+---+---+
+    |       |     |           |           |
+    |   B   |  B  |     U     |     ?     |
+    |       |     |           |           |
+    +---+---+-----+---+---+---+---+---+---+
+    |   |   |     |   |   |   |   |   |   |
+    |   |'+'|     | U | ? | ? | U | ? | ? |
+    |   |   |     |   |   |   |   |   |   |
+    |   +---+-----+---+---+---+---+---+---+
+    |   |   |     |   |   |   |   |   |   |
+    | U |'-'|     | ? | U | ? | ? | U | ? |
+    |   |   |     |   |   |   |   |   |   |
+    |   +---+-----+---+---+---+---+---+---+
+    |   |   |     |           |           |
+    |   |'x'|     |     ?     |     ?     |
+    |   |   |     |           |           |
+    +---+---+-----+---+---+---+---+---+---+
+    |       |     |           |           |
+    |   ?   |     |           |     ?     |
+    |       |     |           |           |
+    +-------+-----+-----------+---+---+---+
+
+        * 'B' = Bounded
+
+        * 'U' = Unbounded
+
+        * '?' = unknown boundedness
+
+        * '+' = positive sign
+
+        * '-' = negative sign
+
+        * 'x' = sign unknown
+
+        * All Bounded -> True
+
+        * 1 Unbounded and the rest Bounded -> False
+
+        * >1 Unbounded, all with same known sign -> False
+
+        * Any Unknown and unknown sign -> None
+
+        * Else -> None
+
+    When the signs are not the same you can have an undefined
+    result as in oo - oo, hence 'bounded' is also undefined.
+    """
+    sign = -1  # sign of unknown or infinite
+    result = True
+    for arg in expr.args:
+        _bounded = ask(Q.finite(arg), assumptions)
+        if _bounded:
+            continue
+        s = ask(Q.extended_positive(arg), assumptions)
+        # if there has been more than one sign or if the sign of this arg
+        # is None and Bounded is None or there was already
+        # an unknown sign, return None
+        if sign != -1 and s != sign or \
+                s is None and None in (_bounded, sign):
+            return None
+        else:
+            sign = s
+        # once False, do not change
+        if result is not False:
+            result = _bounded
+    return result
+
+@FinitePredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    Return True if expr is bounded, False if not and None if unknown.
+
+    Truth Table:
+
+    +---+---+---+--------+
+    |   |   |   |        |
+    |   | B | U |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+    |   |   |   |   |    |
+    |   |   |   | s | /s |
+    |   |   |   |   |    |
+    +---+---+---+---+----+
+    |   |   |   |        |
+    | B | B | U |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+    |   |   |   |   |    |
+    | U |   | U | U | ?  |
+    |   |   |   |   |    |
+    +---+---+---+---+----+
+    |   |   |   |        |
+    | ? |   |   |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+
+        * B = Bounded
+
+        * U = Unbounded
+
+        * ? = unknown boundedness
+
+        * s = signed (hence nonzero)
+
+        * /s = not signed
+    """
+    result = True
+    possible_zero = False
+    for arg in expr.args:
+        _bounded = ask(Q.finite(arg), assumptions)
+        if _bounded:
+            if ask(Q.zero(arg), assumptions) is not False:
+                if result is False:
+                    return None
+                possible_zero = True
+        elif _bounded is None:
+            if result is None:
+                return None
+            if ask(Q.extended_nonzero(arg), assumptions) is None:
+                return None
+            if result is not False:
+                result = None
+        else:
+            if possible_zero:
+                return None
+            result = False
+    return result
+
+@FinitePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Unbounded ** NonZero -> Unbounded
+
+    * Bounded ** Bounded -> Bounded
+
+    * Abs()<=1 ** Positive -> Bounded
+
+    * Abs()>=1 ** Negative -> Bounded
+
+    * Otherwise unknown
+    """
+    if expr.base == E:
+        return ask(Q.finite(expr.exp), assumptions)
+
+    base_bounded = ask(Q.finite(expr.base), assumptions)
+    exp_bounded = ask(Q.finite(expr.exp), assumptions)
+    if base_bounded is None and exp_bounded is None:  # Common Case
+        return None
+    if base_bounded is False and ask(Q.extended_nonzero(expr.exp), assumptions):
+        return False
+    if base_bounded and exp_bounded:
+        is_base_zero = ask(Q.zero(expr.base),assumptions)
+        is_exp_negative = ask(Q.negative(expr.exp),assumptions)
+        if is_base_zero is True and is_exp_negative is True:
+            return False
+        if is_base_zero is not False and is_exp_negative is not False:
+            return None
+        return True
+    if (abs(expr.base) <= 1) == True and ask(Q.extended_positive(expr.exp), assumptions):
+        return True
+    if (abs(expr.base) >= 1) == True and ask(Q.extended_negative(expr.exp), assumptions):
+        return True
+    if (abs(expr.base) >= 1) == True and exp_bounded is False:
+        return False
+    return None
+
+@FinitePredicate.register(exp)
+def _(expr, assumptions):
+    return ask(Q.finite(expr.exp), assumptions)
+
+@FinitePredicate.register(log)
+def _(expr, assumptions):
+    # After complex -> finite fact is registered to new assumption system,
+    # querying Q.infinite may be removed.
+    if ask(Q.infinite(expr.args[0]), assumptions):
+        return False
+    return ask(~Q.zero(expr.args[0]), assumptions)
+
+@FinitePredicate.register_many(cos, sin, Number, Pi, Exp1, GoldenRatio,
+    TribonacciConstant, ImaginaryUnit, sign)
+def _(expr, assumptions):
+    return True
+
+@FinitePredicate.register_many(ComplexInfinity, Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return False
+
+@FinitePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# InfinitePredicate
+
+
+@InfinitePredicate.register(Expr)
+def _(expr, assumptions):
+    is_finite = Q.finite(expr)._eval_ask(assumptions)
+    if is_finite is None:
+        return None
+    return not is_finite
+
+
+# PositiveInfinitePredicate
+
+
+@PositiveInfinitePredicate.register(Infinity)
+def _(expr, assumptions):
+    return True
+
+
+@PositiveInfinitePredicate.register_many(NegativeInfinity, ComplexInfinity)
+def _(expr, assumptions):
+    return False
+
+
+# NegativeInfinitePredicate
+
+
+@NegativeInfinitePredicate.register(NegativeInfinity)
+def _(expr, assumptions):
+    return True
+
+
+@NegativeInfinitePredicate.register_many(Infinity, ComplexInfinity)
+def _(expr, assumptions):
+    return False

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/handlers/common.py

@@ -0,0 +1,164 @@
+"""
+This module defines base class for handlers and some core handlers:
+``Q.commutative`` and ``Q.is_true``.
+"""
+
+from sympy.assumptions import Q, ask, AppliedPredicate
+from sympy.core import Basic, Symbol
+from sympy.core.logic import _fuzzy_group, fuzzy_and, fuzzy_or
+from sympy.core.numbers import NaN, Number
+from sympy.logic.boolalg import (And, BooleanTrue, BooleanFalse, conjuncts,
+    Equivalent, Implies, Not, Or)
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from ..predicates.common import CommutativePredicate, IsTruePredicate
+
+
+class AskHandler:
+    """Base class that all Ask Handlers must inherit."""
+    def __new__(cls, *args, **kwargs):
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. The AskHandler class should
+            be replaced with the multipledispatch handler of Predicate
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+        )
+        return super().__new__(cls, *args, **kwargs)
+
+
+class CommonHandler(AskHandler):
+    # Deprecated
+    """Defines some useful methods common to most Handlers. """
+
+    @staticmethod
+    def AlwaysTrue(expr, assumptions):
+        return True
+
+    @staticmethod
+    def AlwaysFalse(expr, assumptions):
+        return False
+
+    @staticmethod
+    def AlwaysNone(expr, assumptions):
+        return None
+
+    NaN = AlwaysFalse
+
+
+# CommutativePredicate
+
+@CommutativePredicate.register(Symbol)
+def _(expr, assumptions):
+    """Objects are expected to be commutative unless otherwise stated"""
+    assumps = conjuncts(assumptions)
+    if expr.is_commutative is not None:
+        return expr.is_commutative and not ~Q.commutative(expr) in assumps
+    if Q.commutative(expr) in assumps:
+        return True
+    elif ~Q.commutative(expr) in assumps:
+        return False
+    return True
+
+@CommutativePredicate.register(Basic)
+def _(expr, assumptions):
+    for arg in expr.args:
+        if not ask(Q.commutative(arg), assumptions):
+            return False
+    return True
+
+@CommutativePredicate.register(Number)
+def _(expr, assumptions):
+    return True
+
+@CommutativePredicate.register(NaN)
+def _(expr, assumptions):
+    return True
+
+
+# IsTruePredicate
+
+@IsTruePredicate.register(bool)
+def _(expr, assumptions):
+    return expr
+
+@IsTruePredicate.register(BooleanTrue)
+def _(expr, assumptions):
+    return True
+
+@IsTruePredicate.register(BooleanFalse)
+def _(expr, assumptions):
+    return False
+
+@IsTruePredicate.register(AppliedPredicate)
+def _(expr, assumptions):
+    return ask(expr, assumptions)
+
+@IsTruePredicate.register(Not)
+def _(expr, assumptions):
+    arg = expr.args[0]
+    if arg.is_Symbol:
+        # symbol used as abstract boolean object
+        return None
+    value = ask(arg, assumptions=assumptions)
+    if value in (True, False):
+        return not value
+    else:
+        return None
+
+@IsTruePredicate.register(Or)
+def _(expr, assumptions):
+    result = False
+    for arg in expr.args:
+        p = ask(arg, assumptions=assumptions)
+        if p is True:
+            return True
+        if p is None:
+            result = None
+    return result
+
+@IsTruePredicate.register(And)
+def _(expr, assumptions):
+    result = True
+    for arg in expr.args:
+        p = ask(arg, assumptions=assumptions)
+        if p is False:
+            return False
+        if p is None:
+            result = None
+    return result
+
+@IsTruePredicate.register(Implies)
+def _(expr, assumptions):
+    p, q = expr.args
+    return ask(~p | q, assumptions=assumptions)
+
+@IsTruePredicate.register(Equivalent)
+def _(expr, assumptions):
+    p, q = expr.args
+    pt = ask(p, assumptions=assumptions)
+    if pt is None:
+        return None
+    qt = ask(q, assumptions=assumptions)
+    if qt is None:
+        return None
+    return pt == qt
+
+
+#### Helper methods
+def test_closed_group(expr, assumptions, key):
+    """
+    Test for membership in a group with respect
+    to the current operation.
+    """
+    return _fuzzy_group(
+        (ask(key(a), assumptions) for a in expr.args), quick_exit=True)
+
+def ask_all(*queries, assumptions):
+    return fuzzy_and(
+        (ask(query, assumptions) for query in queries))
+
+def ask_any(*queries, assumptions):
+    return fuzzy_or(
+        (ask(query, assumptions) for query in queries))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/handlers/matrices.py

@@ -0,0 +1,716 @@
+"""
+This module contains query handlers responsible for Matrices queries:
+Square, Symmetric, Invertible etc.
+"""
+
+from sympy.logic.boolalg import conjuncts
+from sympy.assumptions import Q, ask
+from sympy.assumptions.handlers import test_closed_group
+from sympy.matrices import MatrixBase
+from sympy.matrices.expressions import (BlockMatrix, BlockDiagMatrix, Determinant,
+    DiagMatrix, DiagonalMatrix, HadamardProduct, Identity, Inverse, MatAdd, MatMul,
+    MatPow, MatrixExpr, MatrixSlice, MatrixSymbol, OneMatrix, Trace, Transpose,
+    ZeroMatrix)
+from sympy.matrices.expressions.blockmatrix import reblock_2x2
+from sympy.matrices.expressions.factorizations import Factorization
+from sympy.matrices.expressions.fourier import DFT
+from sympy.core.logic import fuzzy_and
+from sympy.utilities.iterables import sift
+from sympy.core import Basic
+
+from ..predicates.matrices import (SquarePredicate, SymmetricPredicate,
+    InvertiblePredicate, OrthogonalPredicate, UnitaryPredicate,
+    FullRankPredicate, PositiveDefinitePredicate, UpperTriangularPredicate,
+    LowerTriangularPredicate, DiagonalPredicate, IntegerElementsPredicate,
+    RealElementsPredicate, ComplexElementsPredicate)
+
+
+def _Factorization(predicate, expr, assumptions):
+    if predicate in expr.predicates:
+        return True
+
+
+# SquarePredicate
+
+@SquarePredicate.register(MatrixExpr)
+def _(expr, assumptions):
+    return expr.shape[0] == expr.shape[1]
+
+
+# SymmetricPredicate
+
+@SymmetricPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if all(ask(Q.symmetric(arg), assumptions) for arg in mmul.args):
+        return True
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if len(mmul.args) >= 2 and mmul.args[0] == mmul.args[-1].T:
+        if len(mmul.args) == 2:
+            return True
+        return ask(Q.symmetric(MatMul(*mmul.args[1:-1])), assumptions)
+
+@SymmetricPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.symmetric(base), assumptions)
+    return None
+
+@SymmetricPredicate.register(MatAdd)
+def _(expr, assumptions):
+    return all(ask(Q.symmetric(arg), assumptions) for arg in expr.args)
+
+@SymmetricPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if Q.symmetric(expr) in conjuncts(assumptions):
+        return True
+
+@SymmetricPredicate.register_many(OneMatrix, ZeroMatrix)
+def _(expr, assumptions):
+    return ask(Q.square(expr), assumptions)
+
+@SymmetricPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.symmetric(expr.arg), assumptions)
+
+@SymmetricPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.symmetric(expr.parent), assumptions)
+
+@SymmetricPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+
+# InvertiblePredicate
+
+@InvertiblePredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if all(ask(Q.invertible(arg), assumptions) for arg in mmul.args):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@InvertiblePredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    if exp.is_negative == False:
+        return ask(Q.invertible(base), assumptions)
+    return None
+
+@InvertiblePredicate.register(MatAdd)
+def _(expr, assumptions):
+    return None
+
+@InvertiblePredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if Q.invertible(expr) in conjuncts(assumptions):
+        return True
+
+@InvertiblePredicate.register_many(Identity, Inverse)
+def _(expr, assumptions):
+    return True
+
+@InvertiblePredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@InvertiblePredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@InvertiblePredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.invertible(expr.arg), assumptions)
+
+@InvertiblePredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.invertible(expr.parent), assumptions)
+
+@InvertiblePredicate.register(MatrixBase)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    return expr.rank() == expr.rows
+
+@InvertiblePredicate.register(MatrixExpr)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    return None
+
+@InvertiblePredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if expr.blockshape == (1, 1):
+        return ask(Q.invertible(expr.blocks[0, 0]), assumptions)
+    expr = reblock_2x2(expr)
+    if expr.blockshape == (2, 2):
+        [[A, B], [C, D]] = expr.blocks.tolist()
+        if ask(Q.invertible(A), assumptions) == True:
+            invertible = ask(Q.invertible(D - C * A.I * B), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(B), assumptions) == True:
+            invertible = ask(Q.invertible(C - D * B.I * A), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(C), assumptions) == True:
+            invertible = ask(Q.invertible(B - A * C.I * D), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(D), assumptions) == True:
+            invertible = ask(Q.invertible(A - B * D.I * C), assumptions)
+            if invertible is not None:
+                return invertible
+    return None
+
+@InvertiblePredicate.register(BlockDiagMatrix)
+def _(expr, assumptions):
+    if expr.rowblocksizes != expr.colblocksizes:
+        return None
+    return fuzzy_and([ask(Q.invertible(a), assumptions) for a in expr.diag])
+
+
+# OrthogonalPredicate
+
+@OrthogonalPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.orthogonal(arg), assumptions) for arg in mmul.args) and
+            factor == 1):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@OrthogonalPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp:
+        return ask(Q.orthogonal(base), assumptions)
+    return None
+
+@OrthogonalPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if (len(expr.args) == 1 and
+            ask(Q.orthogonal(expr.args[0]), assumptions)):
+        return True
+
+@OrthogonalPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if (not expr.is_square or
+                    ask(Q.invertible(expr), assumptions) is False):
+        return False
+    if Q.orthogonal(expr) in conjuncts(assumptions):
+        return True
+
+@OrthogonalPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@OrthogonalPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@OrthogonalPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.orthogonal(expr.arg), assumptions)
+
+@OrthogonalPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.orthogonal(expr.parent), assumptions)
+
+@OrthogonalPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.orthogonal, expr, assumptions)
+
+
+# UnitaryPredicate
+
+@UnitaryPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.unitary(arg), assumptions) for arg in mmul.args) and
+            abs(factor) == 1):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@UnitaryPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp:
+        return ask(Q.unitary(base), assumptions)
+    return None
+
+@UnitaryPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if (not expr.is_square or
+                    ask(Q.invertible(expr), assumptions) is False):
+        return False
+    if Q.unitary(expr) in conjuncts(assumptions):
+        return True
+
+@UnitaryPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.unitary(expr.arg), assumptions)
+
+@UnitaryPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.unitary(expr.parent), assumptions)
+
+@UnitaryPredicate.register_many(DFT, Identity)
+def _(expr, assumptions):
+    return True
+
+@UnitaryPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@UnitaryPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.unitary, expr, assumptions)
+
+
+# FullRankPredicate
+
+@FullRankPredicate.register(MatMul)
+def _(expr, assumptions):
+    if all(ask(Q.fullrank(arg), assumptions) for arg in expr.args):
+        return True
+
+@FullRankPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp and ask(~Q.negative(exp), assumptions):
+        return ask(Q.fullrank(base), assumptions)
+    return None
+
+@FullRankPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@FullRankPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@FullRankPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@FullRankPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.fullrank(expr.arg), assumptions)
+
+@FullRankPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if ask(Q.orthogonal(expr.parent), assumptions):
+        return True
+
+
+# PositiveDefinitePredicate
+
+@PositiveDefinitePredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.positive_definite(arg), assumptions)
+            for arg in mmul.args) and factor > 0):
+        return True
+    if (len(mmul.args) >= 2
+            and mmul.args[0] == mmul.args[-1].T
+            and ask(Q.fullrank(mmul.args[0]), assumptions)):
+        return ask(Q.positive_definite(
+            MatMul(*mmul.args[1:-1])), assumptions)
+
+@PositiveDefinitePredicate.register(MatPow)
+def _(expr, assumptions):
+    # a power of a positive definite matrix is positive definite
+    if ask(Q.positive_definite(expr.args[0]), assumptions):
+        return True
+
+@PositiveDefinitePredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.positive_definite(arg), assumptions)
+            for arg in expr.args):
+        return True
+
+@PositiveDefinitePredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if Q.positive_definite(expr) in conjuncts(assumptions):
+        return True
+
+@PositiveDefinitePredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@PositiveDefinitePredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@PositiveDefinitePredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@PositiveDefinitePredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.positive_definite(expr.arg), assumptions)
+
+@PositiveDefinitePredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.positive_definite(expr.parent), assumptions)
+
+
+# UpperTriangularPredicate
+
+@UpperTriangularPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.upper_triangular(m), assumptions) for m in matrices):
+        return True
+
+@UpperTriangularPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.upper_triangular(arg), assumptions) for arg in expr.args):
+        return True
+
+@UpperTriangularPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.upper_triangular(base), assumptions)
+    return None
+
+@UpperTriangularPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if Q.upper_triangular(expr) in conjuncts(assumptions):
+        return True
+
+@UpperTriangularPredicate.register_many(Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@UpperTriangularPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@UpperTriangularPredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.lower_triangular(expr.arg), assumptions)
+
+@UpperTriangularPredicate.register(Inverse)
+def _(expr, assumptions):
+    return ask(Q.upper_triangular(expr.arg), assumptions)
+
+@UpperTriangularPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.upper_triangular(expr.parent), assumptions)
+
+@UpperTriangularPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.upper_triangular, expr, assumptions)
+
+# LowerTriangularPredicate
+
+@LowerTriangularPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.lower_triangular(m), assumptions) for m in matrices):
+        return True
+
+@LowerTriangularPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.lower_triangular(arg), assumptions) for arg in expr.args):
+        return True
+
+@LowerTriangularPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.lower_triangular(base), assumptions)
+    return None
+
+@LowerTriangularPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if Q.lower_triangular(expr) in conjuncts(assumptions):
+        return True
+
+@LowerTriangularPredicate.register_many(Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@LowerTriangularPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@LowerTriangularPredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.upper_triangular(expr.arg), assumptions)
+
+@LowerTriangularPredicate.register(Inverse)
+def _(expr, assumptions):
+    return ask(Q.lower_triangular(expr.arg), assumptions)
+
+@LowerTriangularPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.lower_triangular(expr.parent), assumptions)
+
+@LowerTriangularPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.lower_triangular, expr, assumptions)
+
+
+# DiagonalPredicate
+
+def _is_empty_or_1x1(expr):
+    return expr.shape in ((0, 0), (1, 1))
+
+@DiagonalPredicate.register(MatMul)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.diagonal(m), assumptions) for m in matrices):
+        return True
+
+@DiagonalPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.diagonal(base), assumptions)
+    return None
+
+@DiagonalPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.diagonal(arg), assumptions) for arg in expr.args):
+        return True
+
+@DiagonalPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    if Q.diagonal(expr) in conjuncts(assumptions):
+        return True
+
+@DiagonalPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@DiagonalPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.diagonal(expr.arg), assumptions)
+
+@DiagonalPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.diagonal(expr.parent), assumptions)
+
+@DiagonalPredicate.register_many(DiagonalMatrix, DiagMatrix, Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@DiagonalPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.diagonal, expr, assumptions)
+
+
+# IntegerElementsPredicate
+
+def BM_elements(predicate, expr, assumptions):
+    """ Block Matrix elements. """
+    return all(ask(predicate(b), assumptions) for b in expr.blocks)
+
+def MS_elements(predicate, expr, assumptions):
+    """ Matrix Slice elements. """
+    return ask(predicate(expr.parent), assumptions)
+
+def MatMul_elements(matrix_predicate, scalar_predicate, expr, assumptions):
+    d = sift(expr.args, lambda x: isinstance(x, MatrixExpr))
+    factors, matrices = d[False], d[True]
+    return fuzzy_and([
+        test_closed_group(Basic(*factors), assumptions, scalar_predicate),
+        test_closed_group(Basic(*matrices), assumptions, matrix_predicate)])
+
+
+@IntegerElementsPredicate.register_many(Determinant, HadamardProduct, MatAdd,
+    Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.integer_elements)
+
+@IntegerElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    if exp.is_negative == False:
+        return ask(Q.integer_elements(base), assumptions)
+    return None
+
+@IntegerElementsPredicate.register_many(Identity, OneMatrix, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@IntegerElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.integer_elements, Q.integer, expr, assumptions)
+
+@IntegerElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.integer_elements, expr, assumptions)
+
+@IntegerElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.integer_elements, expr, assumptions)
+
+
+# RealElementsPredicate
+
+@RealElementsPredicate.register_many(Determinant, Factorization, HadamardProduct,
+    MatAdd, Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.real_elements)
+
+@RealElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.real_elements(base), assumptions)
+    return None
+
+@RealElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.real_elements, Q.real, expr, assumptions)
+
+@RealElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.real_elements, expr, assumptions)
+
+@RealElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.real_elements, expr, assumptions)
+
+
+# ComplexElementsPredicate
+
+@ComplexElementsPredicate.register_many(Determinant, Factorization, HadamardProduct,
+    Inverse, MatAdd, Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.complex_elements)
+
+@ComplexElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.complex_elements(base), assumptions)
+    return None
+
+@ComplexElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.complex_elements, Q.complex, expr, assumptions)
+
+@ComplexElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.complex_elements, expr, assumptions)
+
+@ComplexElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.complex_elements, expr, assumptions)
+
+@ComplexElementsPredicate.register(DFT)
+def _(expr, assumptions):
+    return True

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/handlers/ntheory.py

@@ -0,0 +1,279 @@
+"""
+Handlers for keys related to number theory: prime, even, odd, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Float, Mul, Pow, S
+from sympy.core.numbers import (ImaginaryUnit, Infinity, Integer, NaN,
+    NegativeInfinity, NumberSymbol, Rational, int_valued)
+from sympy.functions import Abs, im, re
+from sympy.ntheory import isprime
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from ..predicates.ntheory import (PrimePredicate, CompositePredicate,
+    EvenPredicate, OddPredicate)
+
+
+# PrimePredicate
+
+def _PrimePredicate_number(expr, assumptions):
+    # helper method
+    exact = not expr.atoms(Float)
+    try:
+        i = int(expr.round())
+        if (expr - i).equals(0) is False:
+            raise TypeError
+    except TypeError:
+        return False
+    if exact:
+        return isprime(i)
+    # when not exact, we won't give a True or False
+    # since the number represents an approximate value
+
+@PrimePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_prime
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@PrimePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+    for arg in expr.args:
+        if not ask(Q.integer(arg), assumptions):
+            return None
+    for arg in expr.args:
+        if arg.is_number and arg.is_composite:
+            return False
+
+@PrimePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    Integer**Integer     -> !Prime
+    """
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+    if ask(Q.integer(expr.exp), assumptions) and \
+            ask(Q.integer(expr.base), assumptions):
+        prime_base = ask(Q.prime(expr.base), assumptions)
+        if prime_base is False:
+            return False
+        is_exp_one = ask(Q.eq(expr.exp, 1), assumptions)
+        if is_exp_one is False:
+            return False
+        if prime_base is True and is_exp_one is True:
+            return True
+
+@PrimePredicate.register(Integer)
+def _(expr, assumptions):
+    return isprime(expr)
+
+@PrimePredicate.register_many(Rational, Infinity, NegativeInfinity, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@PrimePredicate.register(Float)
+def _(expr, assumptions):
+    return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(NumberSymbol)
+def _(expr, assumptions):
+    return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# CompositePredicate
+
+@CompositePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_composite
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@CompositePredicate.register(Basic)
+def _(expr, assumptions):
+    _positive = ask(Q.positive(expr), assumptions)
+    if _positive:
+        _integer = ask(Q.integer(expr), assumptions)
+        if _integer:
+            _prime = ask(Q.prime(expr), assumptions)
+            if _prime is None:
+                return
+            # Positive integer which is not prime is not
+            # necessarily composite
+            _is_one = ask(Q.eq(expr, 1), assumptions)
+            if _is_one:
+                return False
+            if _is_one is None:
+                return None
+            return not _prime
+        else:
+            return _integer
+    else:
+        return _positive
+
+
+# EvenPredicate
+
+def _EvenPredicate_number(expr, assumptions):
+    # helper method
+    if isinstance(expr, (float, Float)):
+        if int_valued(expr):
+            return None
+        return False
+    try:
+        i = int(expr.round())
+    except TypeError:
+        return False
+    if not (expr - i).equals(0):
+        return False
+    return i % 2 == 0
+
+@EvenPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_even
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@EvenPredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+
+@EvenPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    Even * Integer    -> Even
+    Even * Odd        -> Even
+    Integer * Odd     -> ?
+    Odd * Odd         -> Odd
+    Even * Even       -> Even
+    Integer * Integer -> Even if Integer + Integer = Odd
+    otherwise         -> ?
+    """
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    even, odd, irrational, acc = False, 0, False, 1
+    for arg in expr.args:
+        # check for all integers and at least one even
+        if ask(Q.integer(arg), assumptions):
+            if ask(Q.even(arg), assumptions):
+                even = True
+            elif ask(Q.odd(arg), assumptions):
+                odd += 1
+            elif not even and acc != 1:
+                if ask(Q.odd(acc + arg), assumptions):
+                    even = True
+        elif ask(Q.irrational(arg), assumptions):
+            # one irrational makes the result False
+            # two makes it undefined
+            if irrational:
+                break
+            irrational = True
+        else:
+            break
+        acc = arg
+    else:
+        if irrational:
+            return False
+        if even:
+            return True
+        if odd == len(expr.args):
+            return False
+
+@EvenPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Even + Odd  -> Odd
+    Even + Even -> Even
+    Odd  + Odd  -> Even
+
+    """
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    _result = True
+    for arg in expr.args:
+        if ask(Q.even(arg), assumptions):
+            pass
+        elif ask(Q.odd(arg), assumptions):
+            _result = not _result
+        else:
+            break
+    else:
+        return _result
+
+@EvenPredicate.register(Pow)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    if ask(Q.integer(expr.exp), assumptions):
+        if ask(Q.positive(expr.exp), assumptions):
+            return ask(Q.even(expr.base), assumptions)
+        elif ask(~Q.negative(expr.exp) & Q.odd(expr.base), assumptions):
+            return False
+        elif expr.base is S.NegativeOne:
+            return False
+
+@EvenPredicate.register(Integer)
+def _(expr, assumptions):
+    return not bool(expr.p & 1)
+
+@EvenPredicate.register_many(Rational, Infinity, NegativeInfinity, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@EvenPredicate.register(NumberSymbol)
+def _(expr, assumptions):
+    return _EvenPredicate_number(expr, assumptions)
+
+@EvenPredicate.register(Abs)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return ask(Q.even(expr.args[0]), assumptions)
+
+@EvenPredicate.register(re)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return ask(Q.even(expr.args[0]), assumptions)
+
+@EvenPredicate.register(im)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return True
+
+@EvenPredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# OddPredicate
+
+@OddPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_odd
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@OddPredicate.register(Basic)
+def _(expr, assumptions):
+    _integer = ask(Q.integer(expr), assumptions)
+    if _integer:
+        _even = ask(Q.even(expr), assumptions)
+        if _even is None:
+            return None
+        return not _even
+    return _integer

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/handlers/order.py

@@ -0,0 +1,440 @@
+"""
+Handlers related to order relations: positive, negative, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Mul, Pow, S
+from sympy.core.logic import fuzzy_not, fuzzy_and, fuzzy_or
+from sympy.core.numbers import E, ImaginaryUnit, NaN, I, pi
+from sympy.functions import Abs, acos, acot, asin, atan, exp, factorial, log
+from sympy.matrices import Determinant, Trace
+from sympy.matrices.expressions.matexpr import MatrixElement
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from ..predicates.order import (NegativePredicate, NonNegativePredicate,
+    NonZeroPredicate, ZeroPredicate, NonPositivePredicate, PositivePredicate,
+    ExtendedNegativePredicate, ExtendedNonNegativePredicate,
+    ExtendedNonPositivePredicate, ExtendedNonZeroPredicate,
+    ExtendedPositivePredicate,)
+
+
+# NegativePredicate
+
+def _NegativePredicate_number(expr, assumptions):
+    r, i = expr.as_real_imag()
+
+    if r == S.NaN or i == S.NaN:
+        return None
+
+    # If the imaginary part can symbolically be shown to be zero then
+    # we just evaluate the real part; otherwise we evaluate the imaginary
+    # part to see if it actually evaluates to zero and if it does then
+    # we make the comparison between the real part and zero.
+    if not i:
+        r = r.evalf(2)
+        if r._prec != 1:
+            return r < 0
+    else:
+        i = i.evalf(2)
+        if i._prec != 1:
+            if i != 0:
+                return False
+            r = r.evalf(2)
+            if r._prec != 1:
+                return r < 0
+
+@NegativePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+
+@NegativePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_negative
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NegativePredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Positive + Positive -> Positive,
+    Negative + Negative -> Negative
+    """
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+
+    r = ask(Q.real(expr), assumptions)
+    if r is not True:
+        return r
+
+    nonpos = 0
+    for arg in expr.args:
+        if ask(Q.negative(arg), assumptions) is not True:
+            if ask(Q.positive(arg), assumptions) is False:
+                nonpos += 1
+            else:
+                break
+    else:
+        if nonpos < len(expr.args):
+            return True
+
+@NegativePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+    result = None
+    for arg in expr.args:
+        if result is None:
+            result = False
+        if ask(Q.negative(arg), assumptions):
+            result = not result
+        elif ask(Q.positive(arg), assumptions):
+            pass
+        else:
+            return
+    return result
+
+@NegativePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    Real ** Even -> NonNegative
+    Real ** Odd  -> same_as_base
+    NonNegative ** Positive -> NonNegative
+    """
+    if expr.base == E:
+        # Exponential is always positive:
+        if ask(Q.real(expr.exp), assumptions):
+            return False
+        return
+
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+    if ask(Q.real(expr.base), assumptions):
+        if ask(Q.positive(expr.base), assumptions):
+            if ask(Q.real(expr.exp), assumptions):
+                return False
+        if ask(Q.even(expr.exp), assumptions):
+            return False
+        if ask(Q.odd(expr.exp), assumptions):
+            return ask(Q.negative(expr.base), assumptions)
+
+@NegativePredicate.register_many(Abs, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@NegativePredicate.register(exp)
+def _(expr, assumptions):
+    if ask(Q.real(expr.exp), assumptions):
+        return False
+    raise MDNotImplementedError
+
+
+# NonNegativePredicate
+
+@NonNegativePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        notnegative = fuzzy_not(_NegativePredicate_number(expr, assumptions))
+        if notnegative:
+            return ask(Q.real(expr), assumptions)
+        else:
+            return notnegative
+
+@NonNegativePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonnegative
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+
+# NonZeroPredicate
+
+@NonZeroPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonzero
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NonZeroPredicate.register(Basic)
+def _(expr, assumptions):
+    if ask(Q.real(expr)) is False:
+        return False
+    if expr.is_number:
+        # if there are no symbols just evalf
+        i = expr.evalf(2)
+        def nonz(i):
+            if i._prec != 1:
+                return i != 0
+        return fuzzy_or(nonz(i) for i in i.as_real_imag())
+
+@NonZeroPredicate.register(Add)
+def _(expr, assumptions):
+    if all(ask(Q.positive(x), assumptions) for x in expr.args) \
+            or all(ask(Q.negative(x), assumptions) for x in expr.args):
+        return True
+
+@NonZeroPredicate.register(Mul)
+def _(expr, assumptions):
+    for arg in expr.args:
+        result = ask(Q.nonzero(arg), assumptions)
+        if result:
+            continue
+        return result
+    return True
+
+@NonZeroPredicate.register(Pow)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr.base), assumptions)
+
+@NonZeroPredicate.register(Abs)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr.args[0]), assumptions)
+
+@NonZeroPredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# ZeroPredicate
+
+@ZeroPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_zero
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ZeroPredicate.register(Basic)
+def _(expr, assumptions):
+    return fuzzy_and([fuzzy_not(ask(Q.nonzero(expr), assumptions)),
+        ask(Q.real(expr), assumptions)])
+
+@ZeroPredicate.register(Mul)
+def _(expr, assumptions):
+    # TODO: This should be deducible from the nonzero handler
+    return fuzzy_or(ask(Q.zero(arg), assumptions) for arg in expr.args)
+
+
+# NonPositivePredicate
+
+@NonPositivePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonpositive
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NonPositivePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        notpositive = fuzzy_not(_PositivePredicate_number(expr, assumptions))
+        if notpositive:
+            return ask(Q.real(expr), assumptions)
+        else:
+            return notpositive
+
+
+# PositivePredicate
+
+def _PositivePredicate_number(expr, assumptions):
+    r, i = expr.as_real_imag()
+    # If the imaginary part can symbolically be shown to be zero then
+    # we just evaluate the real part; otherwise we evaluate the imaginary
+    # part to see if it actually evaluates to zero and if it does then
+    # we make the comparison between the real part and zero.
+    if not i:
+        r = r.evalf(2)
+        if r._prec != 1:
+            return r > 0
+    else:
+        i = i.evalf(2)
+        if i._prec != 1:
+            if i != 0:
+                return False
+            r = r.evalf(2)
+            if r._prec != 1:
+                return r > 0
+
+@PositivePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_positive
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@PositivePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+
+@PositivePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+    result = True
+    for arg in expr.args:
+        if ask(Q.positive(arg), assumptions):
+            continue
+        elif ask(Q.negative(arg), assumptions):
+            result = result ^ True
+        else:
+            return
+    return result
+
+@PositivePredicate.register(Add)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+
+    r = ask(Q.real(expr), assumptions)
+    if r is not True:
+        return r
+
+    nonneg = 0
+    for arg in expr.args:
+        if ask(Q.positive(arg), assumptions) is not True:
+            if ask(Q.negative(arg), assumptions) is False:
+                nonneg += 1
+            else:
+                break
+    else:
+        if nonneg < len(expr.args):
+            return True
+
+@PositivePredicate.register(Pow)
+def _(expr, assumptions):
+    if expr.base == E:
+        if ask(Q.real(expr.exp), assumptions):
+            return True
+        if ask(Q.imaginary(expr.exp), assumptions):
+            return ask(Q.even(expr.exp/(I*pi)), assumptions)
+        return
+
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+    if ask(Q.positive(expr.base), assumptions):
+        if ask(Q.real(expr.exp), assumptions):
+            return True
+    if ask(Q.negative(expr.base), assumptions):
+        if ask(Q.even(expr.exp), assumptions):
+            return True
+        if ask(Q.odd(expr.exp), assumptions):
+            return False
+
+@PositivePredicate.register(exp)
+def _(expr, assumptions):
+    if ask(Q.real(expr.exp), assumptions):
+        return True
+    if ask(Q.imaginary(expr.exp), assumptions):
+        return ask(Q.even(expr.exp/(I*pi)), assumptions)
+
+@PositivePredicate.register(log)
+def _(expr, assumptions):
+    r = ask(Q.real(expr.args[0]), assumptions)
+    if r is not True:
+        return r
+    if ask(Q.positive(expr.args[0] - 1), assumptions):
+        return True
+    if ask(Q.negative(expr.args[0] - 1), assumptions):
+        return False
+
+@PositivePredicate.register(factorial)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.integer(x) & Q.positive(x), assumptions):
+            return True
+
+@PositivePredicate.register(ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@PositivePredicate.register(Abs)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr), assumptions)
+
+@PositivePredicate.register(Trace)
+def _(expr, assumptions):
+    if ask(Q.positive_definite(expr.arg), assumptions):
+        return True
+
+@PositivePredicate.register(Determinant)
+def _(expr, assumptions):
+    if ask(Q.positive_definite(expr.arg), assumptions):
+        return True
+
+@PositivePredicate.register(MatrixElement)
+def _(expr, assumptions):
+    if (expr.i == expr.j
+            and ask(Q.positive_definite(expr.parent), assumptions)):
+        return True
+
+@PositivePredicate.register(atan)
+def _(expr, assumptions):
+    return ask(Q.positive(expr.args[0]), assumptions)
+
+@PositivePredicate.register(asin)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.positive(x) & Q.nonpositive(x - 1), assumptions):
+        return True
+    if ask(Q.negative(x) & Q.nonnegative(x + 1), assumptions):
+        return False
+
+@PositivePredicate.register(acos)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.nonpositive(x - 1) & Q.nonnegative(x + 1), assumptions):
+        return True
+
+@PositivePredicate.register(acot)
+def _(expr, assumptions):
+    return ask(Q.real(expr.args[0]), assumptions)
+
+@PositivePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# ExtendedNegativePredicate
+
+@ExtendedNegativePredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.negative(expr) | Q.negative_infinite(expr), assumptions)
+
+
+# ExtendedPositivePredicate
+
+@ExtendedPositivePredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.positive(expr) | Q.positive_infinite(expr), assumptions)
+
+
+# ExtendedNonZeroPredicate
+
+@ExtendedNonZeroPredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.negative_infinite(expr) | Q.negative(expr) | Q.positive(expr) | Q.positive_infinite(expr),
+        assumptions)
+
+
+# ExtendedNonPositivePredicate
+
+@ExtendedNonPositivePredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.negative_infinite(expr) | Q.negative(expr) | Q.zero(expr),
+        assumptions)
+
+
+# ExtendedNonNegativePredicate
+
+@ExtendedNonNegativePredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.zero(expr) | Q.positive(expr) | Q.positive_infinite(expr),
+        assumptions)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/handlers/sets.py

@@ -0,0 +1,816 @@
+"""
+Handlers for predicates related to set membership: integer, rational, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Mul, Pow, S
+from sympy.core.numbers import (AlgebraicNumber, ComplexInfinity, Exp1, Float,
+    GoldenRatio, ImaginaryUnit, Infinity, Integer, NaN, NegativeInfinity,
+    Number, NumberSymbol, Pi, pi, Rational, TribonacciConstant, E)
+from sympy.core.logic import fuzzy_bool
+from sympy.functions import (Abs, acos, acot, asin, atan, cos, cot, exp, im,
+    log, re, sin, tan)
+from sympy.core.numbers import I
+from sympy.core.relational import Eq
+from sympy.functions.elementary.complexes import conjugate
+from sympy.matrices import Determinant, MatrixBase, Trace
+from sympy.matrices.expressions.matexpr import MatrixElement
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from .common import test_closed_group, ask_all, ask_any
+from ..predicates.sets import (IntegerPredicate, RationalPredicate,
+    IrrationalPredicate, RealPredicate, ExtendedRealPredicate,
+    HermitianPredicate, ComplexPredicate, ImaginaryPredicate,
+    AntihermitianPredicate, AlgebraicPredicate)
+
+
+# IntegerPredicate
+
+def _IntegerPredicate_number(expr, assumptions):
+    # helper function
+        try:
+            i = int(expr.round())
+            if not (expr - i).equals(0):
+                raise TypeError
+            return True
+        except TypeError:
+            return False
+
+@IntegerPredicate.register_many(int, Integer) # type:ignore
+def _(expr, assumptions):
+    return True
+
+@IntegerPredicate.register_many(Exp1, GoldenRatio, ImaginaryUnit, Infinity,
+        NegativeInfinity, Pi, Rational, TribonacciConstant)
+def _(expr, assumptions):
+    return False
+
+@IntegerPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_integer
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@IntegerPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    * Integer + Integer       -> Integer
+    * Integer + !Integer      -> !Integer
+    * !Integer + !Integer -> ?
+    """
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    return test_closed_group(expr, assumptions, Q.integer)
+
+@IntegerPredicate.register(Pow)
+def _(expr,assumptions):
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    if ask_all(~Q.zero(expr.base), Q.finite(expr.base), Q.zero(expr.exp), assumptions=assumptions):
+        return True
+    if ask_all(Q.integer(expr.base), Q.integer(expr.exp), assumptions=assumptions):
+        if ask_any(Q.positive(expr.exp), Q.nonnegative(expr.exp) & ~Q.zero(expr.base), Q.zero(expr.base-1), Q.zero(expr.base+1), assumptions=assumptions):
+            return True
+
+@IntegerPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    * Integer*Integer      -> Integer
+    * Integer*Irrational   -> !Integer
+    * Odd/Even             -> !Integer
+    * Integer*Rational     -> ?
+    """
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    _output = True
+    for arg in expr.args:
+        if not ask(Q.integer(arg), assumptions):
+            if arg.is_Rational:
+                if arg.q == 2:
+                    return ask(Q.even(2*expr), assumptions)
+                if ~(arg.q & 1):
+                    return None
+            elif ask(Q.irrational(arg), assumptions):
+                if _output:
+                    _output = False
+                else:
+                    return
+            else:
+                return
+
+    return _output
+
+@IntegerPredicate.register(Abs)
+def _(expr, assumptions):
+    if ask(Q.integer(expr.args[0]), assumptions):
+        return True
+
+@IntegerPredicate.register_many(Determinant, MatrixElement, Trace)
+def _(expr, assumptions):
+    return ask(Q.integer_elements(expr.args[0]), assumptions)
+
+
+# RationalPredicate
+
+@RationalPredicate.register(Rational)
+def _(expr, assumptions):
+    return True
+
+@RationalPredicate.register(Float)
+def _(expr, assumptions):
+    return None
+
+@RationalPredicate.register_many(Exp1, GoldenRatio, ImaginaryUnit, Infinity,
+    NegativeInfinity, Pi, TribonacciConstant)
+def _(expr, assumptions):
+    return False
+
+@RationalPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_rational
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@RationalPredicate.register_many(Add, Mul)
+def _(expr, assumptions):
+    """
+    * Rational + Rational     -> Rational
+    * Rational + !Rational    -> !Rational
+    * !Rational + !Rational   -> ?
+    """
+    if expr.is_number:
+        if expr.as_real_imag()[1]:
+            return False
+    return test_closed_group(expr, assumptions, Q.rational)
+
+@RationalPredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Rational ** Integer      -> Rational
+    * Irrational ** Rational   -> Irrational
+    * Rational ** Irrational   -> ?
+    """
+    if expr.base == E:
+        x = expr.exp
+        if ask(Q.rational(x), assumptions):
+            return ask(Q.zero(x), assumptions)
+        return
+
+    is_exp_integer = ask(Q.integer(expr.exp), assumptions)
+    if is_exp_integer:
+        is_base_rational = ask(Q.rational(expr.base),assumptions)
+        if is_base_rational:
+            is_base_zero = ask(Q.zero(expr.base),assumptions)
+            if is_base_zero is False:
+                return True
+            if is_base_zero and ask(Q.positive(expr.exp)):
+                return True
+        if ask(Q.algebraic(expr.base),assumptions) is False:
+            return ask(Q.zero(expr.exp), assumptions)
+        if ask(Q.irrational(expr.base),assumptions) and ask(Q.eq(expr.exp,-1)):
+            return False
+        return
+    elif ask(Q.rational(expr.exp), assumptions):
+        if ask(Q.prime(expr.base), assumptions) and is_exp_integer is False:
+            return False
+        if ask(Q.zero(expr.base)) and ask(Q.positive(expr.exp)):
+            return True
+        if ask(Q.eq(expr.base,1)):
+            return True
+
+@RationalPredicate.register_many(asin, atan, cos, sin, tan)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@RationalPredicate.register(exp)
+def _(expr, assumptions):
+    x = expr.exp
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@RationalPredicate.register_many(acot, cot)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return False
+
+@RationalPredicate.register_many(acos, log)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x - 1), assumptions)
+
+
+# IrrationalPredicate
+
+@IrrationalPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_irrational
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@IrrationalPredicate.register(Basic)
+def _(expr, assumptions):
+    _real = ask(Q.real(expr), assumptions)
+    if _real:
+        _rational = ask(Q.rational(expr), assumptions)
+        if _rational is None:
+            return None
+        return not _rational
+    else:
+        return _real
+
+
+# RealPredicate
+
+def _RealPredicate_number(expr, assumptions):
+    # let as_real_imag() work first since the expression may
+    # be simpler to evaluate
+    i = expr.as_real_imag()[1].evalf(2)
+    if i._prec != 1:
+        return not i
+    # allow None to be returned if we couldn't show for sure
+    # that i was 0
+
+@RealPredicate.register_many(Abs, Exp1, Float, GoldenRatio, im, Pi, Rational,
+    re, TribonacciConstant)
+def _(expr, assumptions):
+    return True
+
+@RealPredicate.register_many(ImaginaryUnit, Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return False
+
+@RealPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_real
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@RealPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    * Real + Real              -> Real
+    * Real + (Complex & !Real) -> !Real
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+    return test_closed_group(expr, assumptions, Q.real)
+
+@RealPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    * Real*Real               -> Real
+    * Real*Imaginary          -> !Real
+    * Imaginary*Imaginary     -> Real
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+    result = True
+    for arg in expr.args:
+        if ask(Q.real(arg), assumptions):
+            pass
+        elif ask(Q.imaginary(arg), assumptions):
+            result = result ^ True
+        else:
+            break
+    else:
+        return result
+
+@RealPredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Real**Integer              -> Real
+    * Positive**Real             -> Real
+    * Negative**Real             -> ?
+    * Real**(Integer/Even)       -> Real if base is nonnegative
+    * Real**(Integer/Odd)        -> Real
+    * Imaginary**(Integer/Even)  -> Real
+    * Imaginary**(Integer/Odd)   -> not Real
+    * Imaginary**Real            -> ? since Real could be 0 (giving real)
+                                    or 1 (giving imaginary)
+    * b**Imaginary               -> Real if log(b) is imaginary and b != 0
+                                    and exponent != integer multiple of
+                                    I*pi/log(b)
+    * Real**Real                 -> ? e.g. sqrt(-1) is imaginary and
+                                    sqrt(2) is not
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+
+    if expr.base == E:
+        return ask(
+            Q.integer(expr.exp/I/pi) | Q.real(expr.exp), assumptions
+        )
+
+    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
+        if ask(Q.imaginary(expr.base.exp), assumptions):
+            if ask(Q.imaginary(expr.exp), assumptions):
+                return True
+        # If the i = (exp's arg)/(I*pi) is an integer or half-integer
+        # multiple of I*pi then 2*i will be an integer. In addition,
+        # exp(i*I*pi) = (-1)**i so the overall realness of the expr
+        # can be determined by replacing exp(i*I*pi) with (-1)**i.
+        i = expr.base.exp/I/pi
+        if ask(Q.integer(2*i), assumptions):
+            return ask(Q.real((S.NegativeOne**i)**expr.exp), assumptions)
+        return
+
+    if ask(Q.imaginary(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            odd = ask(Q.odd(expr.exp), assumptions)
+            if odd is not None:
+                return not odd
+            return
+
+    if ask(Q.imaginary(expr.exp), assumptions):
+        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
+        if imlog is not None:
+            # I**i -> real, log(I) is imag;
+            # (2*I)**i -> complex, log(2*I) is not imag
+            return imlog
+
+    if ask(Q.real(expr.base), assumptions):
+        if ask(Q.real(expr.exp), assumptions):
+            if ask(Q.zero(expr.base), assumptions) is not False:
+                if ask(Q.positive(expr.exp), assumptions):
+                    return True
+                return
+            if expr.exp.is_Rational and \
+                    ask(Q.even(expr.exp.q), assumptions):
+                return ask(Q.positive(expr.base), assumptions)
+            elif ask(Q.integer(expr.exp), assumptions):
+                return True
+            elif ask(Q.positive(expr.base), assumptions):
+                return True
+
+@RealPredicate.register_many(cos, sin)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+            return True
+
+@RealPredicate.register(exp)
+def _(expr, assumptions):
+    return ask(
+        Q.integer(expr.exp/I/pi) | Q.real(expr.exp), assumptions
+    )
+
+@RealPredicate.register(log)
+def _(expr, assumptions):
+    return ask(Q.positive(expr.args[0]), assumptions)
+
+@RealPredicate.register_many(Determinant, MatrixElement, Trace)
+def _(expr, assumptions):
+    return ask(Q.real_elements(expr.args[0]), assumptions)
+
+
+# ExtendedRealPredicate
+
+@ExtendedRealPredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.negative_infinite(expr)
+               | Q.negative(expr)
+               | Q.zero(expr)
+               | Q.positive(expr)
+               | Q.positive_infinite(expr),
+            assumptions)
+
+@ExtendedRealPredicate.register_many(Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return True
+
+@ExtendedRealPredicate.register_many(Add, Mul, Pow) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.extended_real)
+
+
+# HermitianPredicate
+
+@HermitianPredicate.register(object) # type:ignore
+def _(expr, assumptions):
+    if isinstance(expr, MatrixBase):
+        return None
+    return ask(Q.real(expr), assumptions)
+
+@HermitianPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian + Hermitian  -> Hermitian
+    * Hermitian + !Hermitian -> !Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    return test_closed_group(expr, assumptions, Q.hermitian)
+
+@HermitianPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    As long as there is at most only one noncommutative term:
+
+    * Hermitian*Hermitian         -> Hermitian
+    * Hermitian*Antihermitian     -> !Hermitian
+    * Antihermitian*Antihermitian -> Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    nccount = 0
+    result = True
+    for arg in expr.args:
+        if ask(Q.antihermitian(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.hermitian(arg), assumptions):
+            break
+        if ask(~Q.commutative(arg), assumptions):
+            nccount += 1
+            if nccount > 1:
+                break
+    else:
+        return result
+
+@HermitianPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian**Integer -> Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    if expr.base == E:
+        if ask(Q.hermitian(expr.exp), assumptions):
+            return True
+        raise MDNotImplementedError
+    if ask(Q.hermitian(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register_many(cos, sin) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.hermitian(expr.args[0]), assumptions):
+        return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.hermitian(expr.exp), assumptions):
+        return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register(MatrixBase) # type:ignore
+def _(mat, assumptions):
+    rows, cols = mat.shape
+    ret_val = True
+    for i in range(rows):
+        for j in range(i, cols):
+            cond = fuzzy_bool(Eq(mat[i, j], conjugate(mat[j, i])))
+            if cond is None:
+                ret_val = None
+            if cond == False:
+                return False
+    if ret_val is None:
+        raise MDNotImplementedError
+    return ret_val
+
+
+# ComplexPredicate
+
+@ComplexPredicate.register_many(Abs, cos, exp, im, ImaginaryUnit, log, Number, # type:ignore
+    NumberSymbol, re, sin)
+def _(expr, assumptions):
+    return True
+
+@ComplexPredicate.register_many(Infinity, NegativeInfinity) # type:ignore
+def _(expr, assumptions):
+    return False
+
+@ComplexPredicate.register(Expr) # type:ignore
+def _(expr, assumptions):
+    ret = expr.is_complex
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ComplexPredicate.register_many(Add, Mul) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.complex)
+
+@ComplexPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    if expr.base == E:
+        return True
+    return test_closed_group(expr, assumptions, Q.complex)
+
+@ComplexPredicate.register_many(Determinant, MatrixElement, Trace) # type:ignore
+def _(expr, assumptions):
+    return ask(Q.complex_elements(expr.args[0]), assumptions)
+
+@ComplexPredicate.register(NaN) # type:ignore
+def _(expr, assumptions):
+    return None
+
+
+# ImaginaryPredicate
+
+def _Imaginary_number(expr, assumptions):
+    # let as_real_imag() work first since the expression may
+    # be simpler to evaluate
+    r = expr.as_real_imag()[0].evalf(2)
+    if r._prec != 1:
+        return not r
+    # allow None to be returned if we couldn't show for sure
+    # that r was 0
+
+@ImaginaryPredicate.register(ImaginaryUnit) # type:ignore
+def _(expr, assumptions):
+    return True
+
+@ImaginaryPredicate.register(Expr) # type:ignore
+def _(expr, assumptions):
+    ret = expr.is_imaginary
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ImaginaryPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Imaginary + Imaginary -> Imaginary
+    * Imaginary + Complex   -> ?
+    * Imaginary + Real      -> !Imaginary
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+
+    reals = 0
+    for arg in expr.args:
+        if ask(Q.imaginary(arg), assumptions):
+            pass
+        elif ask(Q.real(arg), assumptions):
+            reals += 1
+        else:
+            break
+    else:
+        if reals == 0:
+            return True
+        if reals in (1, len(expr.args)):
+            # two reals could sum 0 thus giving an imaginary
+            return False
+
+@ImaginaryPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    * Real*Imaginary      -> Imaginary
+    * Imaginary*Imaginary -> Real
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+    result = False
+    reals = 0
+    for arg in expr.args:
+        if ask(Q.imaginary(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.real(arg), assumptions):
+            break
+    else:
+        if reals == len(expr.args):
+            return False
+        return result
+
+@ImaginaryPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Imaginary**Odd        -> Imaginary
+    * Imaginary**Even       -> Real
+    * b**Imaginary          -> !Imaginary if exponent is an integer
+                               multiple of I*pi/log(b)
+    * Imaginary**Real       -> ?
+    * Positive**Real        -> Real
+    * Negative**Integer     -> Real
+    * Negative**(Integer/2) -> Imaginary
+    * Negative**Real        -> not Imaginary if exponent is not Rational
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+
+    if expr.base == E:
+        a = expr.exp/I/pi
+        return ask(Q.integer(2*a) & ~Q.integer(a), assumptions)
+
+    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
+        if ask(Q.imaginary(expr.base.exp), assumptions):
+            if ask(Q.imaginary(expr.exp), assumptions):
+                return False
+            i = expr.base.exp/I/pi
+            if ask(Q.integer(2*i), assumptions):
+                return ask(Q.imaginary((S.NegativeOne**i)**expr.exp), assumptions)
+
+    if ask(Q.imaginary(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            odd = ask(Q.odd(expr.exp), assumptions)
+            if odd is not None:
+                return odd
+            return
+
+    if ask(Q.imaginary(expr.exp), assumptions):
+        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
+        if imlog is not None:
+            # I**i -> real; (2*I)**i -> complex ==> not imaginary
+            return False
+
+    if ask(Q.real(expr.base) & Q.real(expr.exp), assumptions):
+        if ask(Q.positive(expr.base), assumptions):
+            return False
+        else:
+            rat = ask(Q.rational(expr.exp), assumptions)
+            if not rat:
+                return rat
+            if ask(Q.integer(expr.exp), assumptions):
+                return False
+            else:
+                half = ask(Q.integer(2*expr.exp), assumptions)
+                if half:
+                    return ask(Q.negative(expr.base), assumptions)
+                return half
+
+@ImaginaryPredicate.register(log) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        if ask(Q.positive(expr.args[0]), assumptions):
+            return False
+        return
+    # XXX it should be enough to do
+    # return ask(Q.nonpositive(expr.args[0]), assumptions)
+    # but ask(Q.nonpositive(exp(x)), Q.imaginary(x)) -> None;
+    # it should return True since exp(x) will be either 0 or complex
+    if expr.args[0].func == exp or (expr.args[0].is_Pow and expr.args[0].base == E):
+        if expr.args[0].exp in [I, -I]:
+            return True
+    im = ask(Q.imaginary(expr.args[0]), assumptions)
+    if im is False:
+        return False
+
+@ImaginaryPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    a = expr.exp/I/pi
+    return ask(Q.integer(2*a) & ~Q.integer(a), assumptions)
+
+@ImaginaryPredicate.register_many(Number, NumberSymbol) # type:ignore
+def _(expr, assumptions):
+    return not (expr.as_real_imag()[1] == 0)
+
+@ImaginaryPredicate.register(NaN) # type:ignore
+def _(expr, assumptions):
+    return None
+
+
+# AntihermitianPredicate
+
+@AntihermitianPredicate.register(object) # type:ignore
+def _(expr, assumptions):
+    if isinstance(expr, MatrixBase):
+        return None
+    if ask(Q.zero(expr), assumptions):
+        return True
+    return ask(Q.imaginary(expr), assumptions)
+
+@AntihermitianPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Antihermitian + Antihermitian  -> Antihermitian
+    * Antihermitian + !Antihermitian -> !Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    return test_closed_group(expr, assumptions, Q.antihermitian)
+
+@AntihermitianPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    As long as there is at most only one noncommutative term:
+
+    * Hermitian*Hermitian         -> !Antihermitian
+    * Hermitian*Antihermitian     -> Antihermitian
+    * Antihermitian*Antihermitian -> !Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    nccount = 0
+    result = False
+    for arg in expr.args:
+        if ask(Q.antihermitian(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.hermitian(arg), assumptions):
+            break
+        if ask(~Q.commutative(arg), assumptions):
+            nccount += 1
+            if nccount > 1:
+                break
+    else:
+        return result
+
+@AntihermitianPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian**Integer  -> !Antihermitian
+    * Antihermitian**Even -> !Antihermitian
+    * Antihermitian**Odd  -> Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    if ask(Q.hermitian(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            return False
+    elif ask(Q.antihermitian(expr.base), assumptions):
+        if ask(Q.even(expr.exp), assumptions):
+            return False
+        elif ask(Q.odd(expr.exp), assumptions):
+            return True
+    raise MDNotImplementedError
+
+@AntihermitianPredicate.register(MatrixBase) # type:ignore
+def _(mat, assumptions):
+    rows, cols = mat.shape
+    ret_val = True
+    for i in range(rows):
+        for j in range(i, cols):
+            cond = fuzzy_bool(Eq(mat[i, j], -conjugate(mat[j, i])))
+            if cond is None:
+                ret_val = None
+            if cond == False:
+                return False
+    if ret_val is None:
+        raise MDNotImplementedError
+    return ret_val
+
+
+# AlgebraicPredicate
+
+@AlgebraicPredicate.register_many(AlgebraicNumber, Float, GoldenRatio, # type:ignore
+    ImaginaryUnit, TribonacciConstant)
+def _(expr, assumptions):
+    return True
+
+@AlgebraicPredicate.register_many(ComplexInfinity, Exp1, Infinity, # type:ignore
+    NegativeInfinity, Pi)
+def _(expr, assumptions):
+    return False
+
+@AlgebraicPredicate.register_many(Add, Mul) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.algebraic)
+
+@AlgebraicPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    if expr.base == E:
+        if ask(Q.algebraic(expr.exp), assumptions):
+            return ask(~Q.nonzero(expr.exp), assumptions)
+        return
+    if expr.base == pi:
+        if ask(Q.integer(expr.exp), assumptions) and ask(Q.positive(expr.exp), assumptions):
+            return False
+        return
+    exp_rational = ask(Q.rational(expr.exp), assumptions)
+    base_algebraic = ask(Q.algebraic(expr.base), assumptions)
+    exp_algebraic = ask(Q.algebraic(expr.exp),assumptions)
+    if base_algebraic and exp_algebraic:
+        if exp_rational:
+            return True
+        # Check based on the Gelfond-Schneider theorem:
+        # If the base is algebraic and not equal to 0 or 1, and the exponent
+        # is irrational,then the result is transcendental.
+        if ask(Q.ne(expr.base,0) & Q.ne(expr.base,1)) and exp_rational is False:
+            return False
+
+@AlgebraicPredicate.register(Rational) # type:ignore
+def _(expr, assumptions):
+    return expr.q != 0
+
+@AlgebraicPredicate.register_many(asin, atan, cos, sin, tan) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@AlgebraicPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    x = expr.exp
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@AlgebraicPredicate.register_many(acot, cot) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return False
+
+@AlgebraicPredicate.register_many(acos, log) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x - 1), assumptions)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/predicates/__init__.py

@@ -0,0 +1,5 @@
+"""
+Module to implement predicate classes.
+
+Class of every predicate registered to ``Q`` is defined here.
+"""

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/predicates/calculus.py

@@ -0,0 +1,82 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+class FinitePredicate(Predicate):
+    """
+    Finite number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.finite(x)`` is true if ``x`` is a number but neither an infinity
+    nor a ``NaN``. In other words, ``ask(Q.finite(x))`` is true for all
+    numerical ``x`` having a bounded absolute value.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, S, oo, I, zoo
+    >>> from sympy.abc import x
+    >>> ask(Q.finite(oo))
+    False
+    >>> ask(Q.finite(-oo))
+    False
+    >>> ask(Q.finite(zoo))
+    False
+    >>> ask(Q.finite(1))
+    True
+    >>> ask(Q.finite(2 + 3*I))
+    True
+    >>> ask(Q.finite(x), Q.positive(x))
+    True
+    >>> print(ask(Q.finite(S.NaN)))
+    None
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Finite
+
+    """
+    name = 'finite'
+    handler = Dispatcher(
+        "FiniteHandler",
+        doc=("Handler for Q.finite. Test that an expression is bounded respect"
+        " to all its variables.")
+    )
+
+
+class InfinitePredicate(Predicate):
+    """
+    Infinite number predicate.
+
+    ``Q.infinite(x)`` is true iff the absolute value of ``x`` is
+    infinity.
+
+    """
+    # TODO: Add examples
+    name = 'infinite'
+    handler = Dispatcher(
+        "InfiniteHandler",
+        doc="""Handler for Q.infinite key."""
+    )
+
+
+class PositiveInfinitePredicate(Predicate):
+    """
+    Positive infinity predicate.
+
+    ``Q.positive_infinite(x)`` is true iff ``x`` is positive infinity ``oo``.
+    """
+    name = 'positive_infinite'
+    handler = Dispatcher("PositiveInfiniteHandler")
+
+
+class NegativeInfinitePredicate(Predicate):
+    """
+    Negative infinity predicate.
+
+    ``Q.negative_infinite(x)`` is true iff ``x`` is negative infinity ``-oo``.
+    """
+    name = 'negative_infinite'
+    handler = Dispatcher("NegativeInfiniteHandler")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/predicates/common.py

@@ -0,0 +1,81 @@
+from sympy.assumptions import Predicate, AppliedPredicate, Q
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.multipledispatch import Dispatcher
+
+
+class CommutativePredicate(Predicate):
+    """
+    Commutative predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.commutative(x))`` is true iff ``x`` commutes with any other
+    object with respect to multiplication operation.
+
+    """
+    # TODO: Add examples
+    name = 'commutative'
+    handler = Dispatcher("CommutativeHandler", doc="Handler for key 'commutative'.")
+
+
+binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+
+class IsTruePredicate(Predicate):
+    """
+    Generic predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.is_true(x))`` is true iff ``x`` is true. This only makes
+    sense if ``x`` is a boolean object.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> from sympy.abc import x, y
+    >>> ask(Q.is_true(True))
+    True
+
+    Wrapping another applied predicate just returns the applied predicate.
+
+    >>> Q.is_true(Q.even(x))
+    Q.even(x)
+
+    Wrapping binary relation classes in SymPy core returns applied binary
+    relational predicates.
+
+    >>> from sympy import Eq, Gt
+    >>> Q.is_true(Eq(x, y))
+    Q.eq(x, y)
+    >>> Q.is_true(Gt(x, y))
+    Q.gt(x, y)
+
+    Notes
+    =====
+
+    This class is designed to wrap the boolean objects so that they can
+    behave as if they are applied predicates. Consequently, wrapping another
+    applied predicate is unnecessary and thus it just returns the argument.
+    Also, binary relation classes in SymPy core have binary predicates to
+    represent themselves and thus wrapping them with ``Q.is_true`` converts them
+    to these applied predicates.
+
+    """
+    name = 'is_true'
+    handler = Dispatcher(
+        "IsTrueHandler",
+        doc="Wrapper allowing to query the truth value of a boolean expression."
+    )
+
+    def __call__(self, arg):
+        # No need to wrap another predicate
+        if isinstance(arg, AppliedPredicate):
+            return arg
+        # Convert relational predicates instead of wrapping them
+        if getattr(arg, "is_Relational", False):
+            pred = binrelpreds[type(arg)]
+            return pred(*arg.args)
+        return super().__call__(arg)

miniconda3/envs/active_proaction/lib/python3.10/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'.")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/predicates/ntheory.py

@@ -0,0 +1,126 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class PrimePredicate(Predicate):
+    """
+    Prime number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.prime(x))`` is true iff ``x`` is a natural number greater
+    than 1 that has no positive divisors other than ``1`` and the
+    number itself.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.prime(0))
+    False
+    >>> ask(Q.prime(1))
+    False
+    >>> ask(Q.prime(2))
+    True
+    >>> ask(Q.prime(20))
+    False
+    >>> ask(Q.prime(-3))
+    False
+
+    """
+    name = 'prime'
+    handler = Dispatcher(
+        "PrimeHandler",
+        doc=("Handler for key 'prime'. Test that an expression represents a prime"
+        " number. When the expression is an exact number, the result (when True)"
+        " is subject to the limitations of isprime() which is used to return the "
+        "result.")
+    )
+
+
+class CompositePredicate(Predicate):
+    """
+    Composite number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.composite(x))`` is true iff ``x`` is a positive integer and has
+    at least one positive divisor other than ``1`` and the number itself.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.composite(0))
+    False
+    >>> ask(Q.composite(1))
+    False
+    >>> ask(Q.composite(2))
+    False
+    >>> ask(Q.composite(20))
+    True
+
+    """
+    name = 'composite'
+    handler = Dispatcher("CompositeHandler", doc="Handler for key 'composite'.")
+
+
+class EvenPredicate(Predicate):
+    """
+    Even number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.even(x))`` is true iff ``x`` belongs to the set of even
+    integers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, pi
+    >>> ask(Q.even(0))
+    True
+    >>> ask(Q.even(2))
+    True
+    >>> ask(Q.even(3))
+    False
+    >>> ask(Q.even(pi))
+    False
+
+    """
+    name = 'even'
+    handler = Dispatcher("EvenHandler", doc="Handler for key 'even'.")
+
+
+class OddPredicate(Predicate):
+    """
+    Odd number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.odd(x))`` is true iff ``x`` belongs to the set of odd numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, pi
+    >>> ask(Q.odd(0))
+    False
+    >>> ask(Q.odd(2))
+    False
+    >>> ask(Q.odd(3))
+    True
+    >>> ask(Q.odd(pi))
+    False
+
+    """
+    name = 'odd'
+    handler = Dispatcher(
+        "OddHandler",
+        doc=("Handler for key 'odd'. Test that an expression represents an odd"
+        " number.")
+    )

miniconda3/envs/active_proaction/lib/python3.10/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")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/predicates/sets.py

@@ -0,0 +1,399 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class IntegerPredicate(Predicate):
+    """
+    Integer predicate.
+
+    Explanation
+    ===========
+
+    ``Q.integer(x)`` is true iff ``x`` belongs to the set of integer
+    numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, S
+    >>> ask(Q.integer(5))
+    True
+    >>> ask(Q.integer(S(1)/2))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Integer
+
+    """
+    name = 'integer'
+    handler = Dispatcher(
+        "IntegerHandler",
+        doc=("Handler for Q.integer.\n\n"
+        "Test that an expression belongs to the field of integer numbers.")
+    )
+
+
+class NonIntegerPredicate(Predicate):
+    """
+    Non-integer extended real predicate.
+    """
+    name = 'noninteger'
+    handler = Dispatcher(
+        "NonIntegerHandler",
+        doc=("Handler for Q.noninteger.\n\n"
+        "Test that an expression is a non-integer extended real number.")
+    )
+
+
+class RationalPredicate(Predicate):
+    """
+    Rational number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.rational(x)`` is true iff ``x`` belongs to the set of
+    rational numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi, S
+    >>> ask(Q.rational(0))
+    True
+    >>> ask(Q.rational(S(1)/2))
+    True
+    >>> ask(Q.rational(pi))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Rational_number
+
+    """
+    name = 'rational'
+    handler = Dispatcher(
+        "RationalHandler",
+        doc=("Handler for Q.rational.\n\n"
+        "Test that an expression belongs to the field of rational numbers.")
+    )
+
+
+class IrrationalPredicate(Predicate):
+    """
+    Irrational number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.irrational(x)`` is true iff ``x``  is any real number that
+    cannot be expressed as a ratio of integers.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi, S, I
+    >>> ask(Q.irrational(0))
+    False
+    >>> ask(Q.irrational(S(1)/2))
+    False
+    >>> ask(Q.irrational(pi))
+    True
+    >>> ask(Q.irrational(I))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Irrational_number
+
+    """
+    name = 'irrational'
+    handler = Dispatcher(
+        "IrrationalHandler",
+        doc=("Handler for Q.irrational.\n\n"
+        "Test that an expression is irrational numbers.")
+    )
+
+
+class RealPredicate(Predicate):
+    r"""
+    Real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.real(x)`` is true iff ``x`` is a real number, i.e., it is in the
+    interval `(-\infty, \infty)`.  Note that, in particular the
+    infinities are not real. Use ``Q.extended_real`` if you want to
+    consider those as well.
+
+    A few important facts about reals:
+
+    - Every real number is positive, negative, or zero.  Furthermore,
+        because these sets are pairwise disjoint, each real number is
+        exactly one of those three.
+
+    - Every real number is also complex.
+
+    - Every real number is finite.
+
+    - Every real number is either rational or irrational.
+
+    - Every real number is either algebraic or transcendental.
+
+    - The facts ``Q.negative``, ``Q.zero``, ``Q.positive``,
+        ``Q.nonnegative``, ``Q.nonpositive``, ``Q.nonzero``,
+        ``Q.integer``, ``Q.rational``, and ``Q.irrational`` all imply
+        ``Q.real``, as do all facts that imply those facts.
+
+    - The facts ``Q.algebraic``, and ``Q.transcendental`` do not imply
+        ``Q.real``; they imply ``Q.complex``. An algebraic or
+        transcendental number may or may not be real.
+
+    - The "non" facts (i.e., ``Q.nonnegative``, ``Q.nonzero``,
+        ``Q.nonpositive`` and ``Q.noninteger``) are not equivalent to
+        not the fact, but rather, not the fact *and* ``Q.real``.
+        For example, ``Q.nonnegative`` means ``~Q.negative & Q.real``.
+        So for example, ``I`` is not nonnegative, nonzero, or
+        nonpositive.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols
+    >>> x = symbols('x')
+    >>> ask(Q.real(x), Q.positive(x))
+    True
+    >>> ask(Q.real(0))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Real_number
+
+    """
+    name = 'real'
+    handler = Dispatcher(
+        "RealHandler",
+        doc=("Handler for Q.real.\n\n"
+        "Test that an expression belongs to the field of real numbers.")
+    )
+
+
+class ExtendedRealPredicate(Predicate):
+    r"""
+    Extended real predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_real(x)`` is true iff ``x`` is a real number or
+    `\{-\infty, \infty\}`.
+
+    See documentation of ``Q.real`` for more information about related
+    facts.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, oo, I
+    >>> ask(Q.extended_real(1))
+    True
+    >>> ask(Q.extended_real(I))
+    False
+    >>> ask(Q.extended_real(oo))
+    True
+
+    """
+    name = 'extended_real'
+    handler = Dispatcher(
+        "ExtendedRealHandler",
+        doc=("Handler for Q.extended_real.\n\n"
+        "Test that an expression belongs to the field of extended real\n"
+        "numbers, that is real numbers union {Infinity, -Infinity}.")
+    )
+
+
+class HermitianPredicate(Predicate):
+    """
+    Hermitian predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.hermitian(x))`` is true iff ``x`` belongs to the set of
+    Hermitian operators.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HermitianOperator.html
+
+    """
+    # TODO: Add examples
+    name = 'hermitian'
+    handler = Dispatcher(
+        "HermitianHandler",
+        doc=("Handler for Q.hermitian.\n\n"
+        "Test that an expression belongs to the field of Hermitian operators.")
+    )
+
+
+class ComplexPredicate(Predicate):
+    """
+    Complex number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.complex(x)`` is true iff ``x`` belongs to the set of complex
+    numbers. Note that every complex number is finite.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Symbol, ask, I, oo
+    >>> x = Symbol('x')
+    >>> ask(Q.complex(0))
+    True
+    >>> ask(Q.complex(2 + 3*I))
+    True
+    >>> ask(Q.complex(oo))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Complex_number
+
+    """
+    name = 'complex'
+    handler = Dispatcher(
+        "ComplexHandler",
+        doc=("Handler for Q.complex.\n\n"
+        "Test that an expression belongs to the field of complex numbers.")
+    )
+
+
+class ImaginaryPredicate(Predicate):
+    """
+    Imaginary number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.imaginary(x)`` is true iff ``x`` can be written as a real
+    number multiplied by the imaginary unit ``I``. Please note that ``0``
+    is not considered to be an imaginary number.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+    >>> ask(Q.imaginary(3*I))
+    True
+    >>> ask(Q.imaginary(2 + 3*I))
+    False
+    >>> ask(Q.imaginary(0))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Imaginary_number
+
+    """
+    name = 'imaginary'
+    handler = Dispatcher(
+        "ImaginaryHandler",
+        doc=("Handler for Q.imaginary.\n\n"
+        "Test that an expression belongs to the field of imaginary numbers,\n"
+        "that is, numbers in the form x*I, where x is real.")
+    )
+
+
+class AntihermitianPredicate(Predicate):
+    """
+    Antihermitian predicate.
+
+    Explanation
+    ===========
+
+    ``Q.antihermitian(x)`` is true iff ``x`` belongs to the field of
+    antihermitian operators, i.e., operators in the form ``x*I``, where
+    ``x`` is Hermitian.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HermitianOperator.html
+
+    """
+    # TODO: Add examples
+    name = 'antihermitian'
+    handler = Dispatcher(
+        "AntiHermitianHandler",
+        doc=("Handler for Q.antihermitian.\n\n"
+        "Test that an expression belongs to the field of anti-Hermitian\n"
+        "operators, that is, operators in the form x*I, where x is Hermitian.")
+    )
+
+
+class AlgebraicPredicate(Predicate):
+    r"""
+    Algebraic number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.algebraic(x)`` is true iff ``x`` belongs to the set of
+    algebraic numbers. ``x`` is algebraic if there is some polynomial
+    in ``p(x)\in \mathbb\{Q\}[x]`` such that ``p(x) = 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, sqrt, I, pi
+    >>> ask(Q.algebraic(sqrt(2)))
+    True
+    >>> ask(Q.algebraic(I))
+    True
+    >>> ask(Q.algebraic(pi))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Algebraic_number
+
+    """
+    name = 'algebraic'
+    AlgebraicHandler = Dispatcher(
+        "AlgebraicHandler",
+        doc="""Handler for Q.algebraic key."""
+    )
+
+
+class TranscendentalPredicate(Predicate):
+    """
+    Transcedental number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.transcendental(x)`` is true iff ``x`` belongs to the set of
+    transcendental numbers. A transcendental number is a real
+    or complex number that is not algebraic.
+
+    """
+    # TODO: Add examples
+    name = 'transcendental'
+    handler = Dispatcher(
+        "Transcendental",
+        doc="""Handler for Q.transcendental key."""
+    )

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/relation/__init__.py

@@ -0,0 +1,13 @@
+"""
+A module to implement finitary relations [1] as predicate.
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Finitary_relation
+
+"""
+
+__all__ = ['BinaryRelation', 'AppliedBinaryRelation']
+
+from .binrel import BinaryRelation, AppliedBinaryRelation

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/relation/binrel.py

@@ -0,0 +1,212 @@
+"""
+General binary relations.
+"""
+from typing import Optional
+
+from sympy.core.singleton import S
+from sympy.assumptions import AppliedPredicate, ask, Predicate, Q  # type: ignore
+from sympy.core.kind import BooleanKind
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.logic.boolalg import conjuncts, Not
+
+__all__ = ["BinaryRelation", "AppliedBinaryRelation"]
+
+
+class BinaryRelation(Predicate):
+    """
+    Base class for all binary relational predicates.
+
+    Explanation
+    ===========
+
+    Binary relation takes two arguments and returns ``AppliedBinaryRelation``
+    instance. To evaluate it to boolean value, use :obj:`~.ask()` or
+    :obj:`~.refine()` function.
+
+    You can add support for new types by registering the handler to dispatcher.
+    See :obj:`~.Predicate()` for more information about predicate dispatching.
+
+    Examples
+    ========
+
+    Applying and evaluating to boolean value:
+
+    >>> from sympy import Q, ask, sin, cos
+    >>> from sympy.abc import x
+    >>> Q.eq(sin(x)**2+cos(x)**2, 1)
+    Q.eq(sin(x)**2 + cos(x)**2, 1)
+    >>> ask(_)
+    True
+
+    You can define a new binary relation by subclassing and dispatching.
+    Here, we define a relation $R$ such that $x R y$ returns true if
+    $x = y + 1$.
+
+    >>> from sympy import ask, Number, Q
+    >>> from sympy.assumptions import BinaryRelation
+    >>> class MyRel(BinaryRelation):
+    ...     name = "R"
+    ...     is_reflexive = False
+    >>> Q.R = MyRel()
+    >>> @Q.R.register(Number, Number)
+    ... def _(n1, n2, assumptions):
+    ...     return ask(Q.zero(n1 - n2 - 1), assumptions)
+    >>> Q.R(2, 1)
+    Q.R(2, 1)
+
+    Now, we can use ``ask()`` to evaluate it to boolean value.
+
+    >>> ask(Q.R(2, 1))
+    True
+    >>> ask(Q.R(1, 2))
+    False
+
+    ``Q.R`` returns ``False`` with minimum cost if two arguments have same
+    structure because it is antireflexive relation [1] by
+    ``is_reflexive = False``.
+
+    >>> ask(Q.R(x, x))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Reflexive_relation
+    """
+
+    is_reflexive: Optional[bool] = None
+    is_symmetric: Optional[bool] = None
+
+    def __call__(self, *args):
+        if not len(args) == 2:
+            raise ValueError("Binary relation takes two arguments, but got %s." % len(args))
+        return AppliedBinaryRelation(self, *args)
+
+    @property
+    def reversed(self):
+        if self.is_symmetric:
+            return self
+        return None
+
+    @property
+    def negated(self):
+        return None
+
+    def _compare_reflexive(self, lhs, rhs):
+        # quick exit for structurally same arguments
+        # do not check != here because it cannot catch the
+        # equivalent arguments with different structures.
+
+        # reflexivity does not hold to NaN
+        if lhs is S.NaN or rhs is S.NaN:
+            return None
+
+        reflexive = self.is_reflexive
+        if reflexive is None:
+            pass
+        elif reflexive and (lhs == rhs):
+            return True
+        elif not reflexive and (lhs == rhs):
+            return False
+        return None
+
+    def eval(self, args, assumptions=True):
+        # quick exit for structurally same arguments
+        ret = self._compare_reflexive(*args)
+        if ret is not None:
+            return ret
+
+        # don't perform simplify on args here. (done by AppliedBinaryRelation._eval_ask)
+        # evaluate by multipledispatch
+        lhs, rhs = args
+        ret = self.handler(lhs, rhs, assumptions=assumptions)
+        if ret is not None:
+            return ret
+
+        # check reversed order if the relation is reflexive
+        if self.is_reflexive:
+            types = (type(lhs), type(rhs))
+            if self.handler.dispatch(*types) is not self.handler.dispatch(*reversed(types)):
+                ret = self.handler(rhs, lhs, assumptions=assumptions)
+
+        return ret
+
+
+class AppliedBinaryRelation(AppliedPredicate):
+    """
+    The class of expressions resulting from applying ``BinaryRelation``
+    to the arguments.
+
+    """
+
+    @property
+    def lhs(self):
+        """The left-hand side of the relation."""
+        return self.arguments[0]
+
+    @property
+    def rhs(self):
+        """The right-hand side of the relation."""
+        return self.arguments[1]
+
+    @property
+    def reversed(self):
+        """
+        Try to return the relationship with sides reversed.
+        """
+        revfunc = self.function.reversed
+        if revfunc is None:
+            return self
+        return revfunc(self.rhs, self.lhs)
+
+    @property
+    def reversedsign(self):
+        """
+        Try to return the relationship with signs reversed.
+        """
+        revfunc = self.function.reversed
+        if revfunc is None:
+            return self
+        if not any(side.kind is BooleanKind for side in self.arguments):
+            return revfunc(-self.lhs, -self.rhs)
+        return self
+
+    @property
+    def negated(self):
+        neg_rel = self.function.negated
+        if neg_rel is None:
+            return Not(self, evaluate=False)
+        return neg_rel(*self.arguments)
+
+    def _eval_ask(self, assumptions):
+        conj_assumps = set()
+        binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+        for a in conjuncts(assumptions):
+            if a.func in binrelpreds:
+                conj_assumps.add(binrelpreds[type(a)](*a.args))
+            else:
+                conj_assumps.add(a)
+
+        # After CNF in assumptions module is modified to take polyadic
+        # predicate, this will be removed
+        if any(rel in conj_assumps for rel in (self, self.reversed)):
+            return True
+        neg_rels = (self.negated, self.reversed.negated, Not(self, evaluate=False),
+            Not(self.reversed, evaluate=False))
+        if any(rel in conj_assumps for rel in neg_rels):
+            return False
+
+        # evaluation using multipledispatching
+        ret = self.function.eval(self.arguments, assumptions)
+        if ret is not None:
+            return ret
+
+        # simplify the args and try again
+        args = tuple(a.simplify() for a in self.arguments)
+        return self.function.eval(args, assumptions)
+
+    def __bool__(self):
+        ret = ask(self)
+        if ret is None:
+            raise TypeError("Cannot determine truth value of %s" % self)
+        return ret

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/relation/equality.py

@@ -0,0 +1,302 @@
+"""
+Module for mathematical equality [1] and inequalities [2].
+
+The purpose of this module is to provide the instances which represent the
+binary predicates in order to combine the relationals into logical inference
+system. Objects such as ``Q.eq``, ``Q.lt`` should remain internal to
+assumptions module, and user must use the classes such as :obj:`~.Eq()`,
+:obj:`~.Lt()` instead to construct the relational expressions.
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Equality_(mathematics)
+.. [2] https://en.wikipedia.org/wiki/Inequality_(mathematics)
+"""
+from sympy.assumptions import Q
+from sympy.core.relational import is_eq, is_neq, is_gt, is_ge, is_lt, is_le
+
+from .binrel import BinaryRelation
+
+__all__ = ['EqualityPredicate', 'UnequalityPredicate', 'StrictGreaterThanPredicate',
+    'GreaterThanPredicate', 'StrictLessThanPredicate', 'LessThanPredicate']
+
+
+class EqualityPredicate(BinaryRelation):
+    """
+    Binary predicate for $=$.
+
+    The purpose of this class is to provide the instance which represent
+    the equality predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Eq()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_eq`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.eq(0, 0)
+    Q.eq(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Eq
+
+    """
+    is_reflexive = True
+    is_symmetric = True
+
+    name = 'eq'
+    handler = None  # Do not allow dispatching by this predicate
+
+    @property
+    def negated(self):
+        return Q.ne
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_eq is None
+            assumptions = None
+        return is_eq(*args, assumptions)
+
+
+class UnequalityPredicate(BinaryRelation):
+    r"""
+    Binary predicate for $\neq$.
+
+    The purpose of this class is to provide the instance which represent
+    the inequation predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Ne()` instead to construct the inequation expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_neq`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.ne(0, 0)
+    Q.ne(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Ne
+
+    """
+    is_reflexive = False
+    is_symmetric = True
+
+    name = 'ne'
+    handler = None
+
+    @property
+    def negated(self):
+        return Q.eq
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_neq is None
+            assumptions = None
+        return is_neq(*args, assumptions)
+
+
+class StrictGreaterThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $>$.
+
+    The purpose of this class is to provide the instance which represent
+    the ">" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Gt()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_gt`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.gt(0, 0)
+    Q.gt(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Gt
+
+    """
+    is_reflexive = False
+    is_symmetric = False
+
+    name = 'gt'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.lt
+
+    @property
+    def negated(self):
+        return Q.le
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_gt is None
+            assumptions = None
+        return is_gt(*args, assumptions)
+
+
+class GreaterThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $>=$.
+
+    The purpose of this class is to provide the instance which represent
+    the ">=" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Ge()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_ge`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.ge(0, 0)
+    Q.ge(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Ge
+
+    """
+    is_reflexive = True
+    is_symmetric = False
+
+    name = 'ge'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.le
+
+    @property
+    def negated(self):
+        return Q.lt
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_ge is None
+            assumptions = None
+        return is_ge(*args, assumptions)
+
+
+class StrictLessThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $<$.
+
+    The purpose of this class is to provide the instance which represent
+    the "<" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Lt()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_lt`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.lt(0, 0)
+    Q.lt(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Lt
+
+    """
+    is_reflexive = False
+    is_symmetric = False
+
+    name = 'lt'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.gt
+
+    @property
+    def negated(self):
+        return Q.ge
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_lt is None
+            assumptions = None
+        return is_lt(*args, assumptions)
+
+
+class LessThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $<=$.
+
+    The purpose of this class is to provide the instance which represent
+    the "<=" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Le()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_le`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.le(0, 0)
+    Q.le(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Le
+
+    """
+    is_reflexive = True
+    is_symmetric = False
+
+    name = 'le'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.ge
+
+    @property
+    def negated(self):
+        return Q.gt
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_le is None
+            assumptions = None
+        return is_le(*args, assumptions)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_assumptions_2.py

@@ -0,0 +1,35 @@
+"""
+rename this to test_assumptions.py when the old assumptions system is deleted
+"""
+from sympy.abc import x, y
+from sympy.assumptions.assume import global_assumptions
+from sympy.assumptions.ask import Q
+from sympy.printing import pretty
+
+
+def test_equal():
+    """Test for equality"""
+    assert Q.positive(x) == Q.positive(x)
+    assert Q.positive(x) != ~Q.positive(x)
+    assert ~Q.positive(x) == ~Q.positive(x)
+
+
+def test_pretty():
+    assert pretty(Q.positive(x)) == "Q.positive(x)"
+    assert pretty(
+        {Q.positive, Q.integer}) == "{Q.integer, Q.positive}"
+
+
+def test_global():
+    """Test for global assumptions"""
+    global_assumptions.add(x > 0)
+    assert (x > 0) in global_assumptions
+    global_assumptions.remove(x > 0)
+    assert not (x > 0) in global_assumptions
+    # same with multiple of assumptions
+    global_assumptions.add(x > 0, y > 0)
+    assert (x > 0) in global_assumptions
+    assert (y > 0) in global_assumptions
+    global_assumptions.clear()
+    assert not (x > 0) in global_assumptions
+    assert not (y > 0) in global_assumptions

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_context.py

@@ -0,0 +1,39 @@
+from sympy.assumptions import ask, Q
+from sympy.assumptions.assume import assuming, global_assumptions
+from sympy.abc import x, y
+
+def test_assuming():
+    with assuming(Q.integer(x)):
+        assert ask(Q.integer(x))
+    assert not ask(Q.integer(x))
+
+def test_assuming_nested():
+    assert not ask(Q.integer(x))
+    assert not ask(Q.integer(y))
+    with assuming(Q.integer(x)):
+        assert ask(Q.integer(x))
+        assert not ask(Q.integer(y))
+        with assuming(Q.integer(y)):
+            assert ask(Q.integer(x))
+            assert ask(Q.integer(y))
+        assert ask(Q.integer(x))
+        assert not ask(Q.integer(y))
+    assert not ask(Q.integer(x))
+    assert not ask(Q.integer(y))
+
+def test_finally():
+    try:
+        with assuming(Q.integer(x)):
+            1/0
+    except ZeroDivisionError:
+        pass
+    assert not ask(Q.integer(x))
+
+def test_remove_safe():
+    global_assumptions.add(Q.integer(x))
+    with assuming():
+        assert ask(Q.integer(x))
+        global_assumptions.remove(Q.integer(x))
+        assert not ask(Q.integer(x))
+    assert ask(Q.integer(x))
+    global_assumptions.clear() # for the benefit of other tests

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_matrices.py

@@ -0,0 +1,283 @@
+from sympy.assumptions.ask import (Q, ask)
+from sympy.core.symbol import Symbol
+from sympy.matrices.expressions.diagonal import (DiagMatrix, DiagonalMatrix)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions import (MatrixSymbol, Identity, ZeroMatrix,
+        OneMatrix, Trace, MatrixSlice, Determinant, BlockMatrix, BlockDiagMatrix)
+from sympy.matrices.expressions.factorizations import LofLU
+from sympy.testing.pytest import XFAIL
+
+X = MatrixSymbol('X', 2, 2)
+Y = MatrixSymbol('Y', 2, 3)
+Z = MatrixSymbol('Z', 2, 2)
+A1x1 = MatrixSymbol('A1x1', 1, 1)
+B1x1 = MatrixSymbol('B1x1', 1, 1)
+C0x0 = MatrixSymbol('C0x0', 0, 0)
+V1 = MatrixSymbol('V1', 2, 1)
+V2 = MatrixSymbol('V2', 2, 1)
+
+def test_square():
+    assert ask(Q.square(X))
+    assert not ask(Q.square(Y))
+    assert ask(Q.square(Y*Y.T))
+
+def test_invertible():
+    assert ask(Q.invertible(X), Q.invertible(X))
+    assert ask(Q.invertible(Y)) is False
+    assert ask(Q.invertible(X*Y), Q.invertible(X)) is False
+    assert ask(Q.invertible(X*Z), Q.invertible(X)) is None
+    assert ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z)) is True
+    assert ask(Q.invertible(X.T)) is None
+    assert ask(Q.invertible(X.T), Q.invertible(X)) is True
+    assert ask(Q.invertible(X.I)) is True
+    assert ask(Q.invertible(Identity(3))) is True
+    assert ask(Q.invertible(ZeroMatrix(3, 3))) is False
+    assert ask(Q.invertible(OneMatrix(1, 1))) is True
+    assert ask(Q.invertible(OneMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), Q.fullrank(X) & Q.square(X))
+
+def test_singular():
+    assert ask(Q.singular(X)) is None
+    assert ask(Q.singular(X), Q.invertible(X)) is False
+    assert ask(Q.singular(X), ~Q.invertible(X)) is True
+
+@XFAIL
+def test_invertible_fullrank():
+    assert ask(Q.invertible(X), Q.fullrank(X)) is True
+
+
+def test_invertible_BlockMatrix():
+    assert ask(Q.invertible(BlockMatrix([Identity(3)]))) == True
+    assert ask(Q.invertible(BlockMatrix([ZeroMatrix(3, 3)]))) == False
+
+    X = Matrix([[1, 2, 3], [3, 5, 4]])
+    Y = Matrix([[4, 2, 7], [2, 3, 5]])
+    # non-invertible A block
+    assert ask(Q.invertible(BlockMatrix([
+        [Matrix.ones(3, 3), Y.T],
+        [X, Matrix.eye(2)],
+    ]))) == True
+    # non-invertible B block
+    assert ask(Q.invertible(BlockMatrix([
+        [Y.T, Matrix.ones(3, 3)],
+        [Matrix.eye(2), X],
+    ]))) == True
+    # non-invertible C block
+    assert ask(Q.invertible(BlockMatrix([
+        [X, Matrix.eye(2)],
+        [Matrix.ones(3, 3), Y.T],
+    ]))) == True
+    # non-invertible D block
+    assert ask(Q.invertible(BlockMatrix([
+        [Matrix.eye(2), X],
+        [Y.T, Matrix.ones(3, 3)],
+    ]))) == True
+
+
+def test_invertible_BlockDiagMatrix():
+    assert ask(Q.invertible(BlockDiagMatrix(Identity(3), Identity(5)))) == True
+    assert ask(Q.invertible(BlockDiagMatrix(ZeroMatrix(3, 3), Identity(5)))) == False
+    assert ask(Q.invertible(BlockDiagMatrix(Identity(3), OneMatrix(5, 5)))) == False
+
+
+def test_symmetric():
+    assert ask(Q.symmetric(X), Q.symmetric(X))
+    assert ask(Q.symmetric(X*Z), Q.symmetric(X)) is None
+    assert ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z)) is True
+    assert ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z)) is True
+    assert ask(Q.symmetric(Y)) is False
+    assert ask(Q.symmetric(Y*Y.T)) is True
+    assert ask(Q.symmetric(Y.T*X*Y)) is None
+    assert ask(Q.symmetric(Y.T*X*Y), Q.symmetric(X)) is True
+    assert ask(Q.symmetric(X**10), Q.symmetric(X)) is True
+    assert ask(Q.symmetric(A1x1)) is True
+    assert ask(Q.symmetric(A1x1 + B1x1)) is True
+    assert ask(Q.symmetric(A1x1 * B1x1)) is True
+    assert ask(Q.symmetric(V1.T*V1)) is True
+    assert ask(Q.symmetric(V1.T*(V1 + V2))) is True
+    assert ask(Q.symmetric(V1.T*(V1 + V2) + A1x1)) is True
+    assert ask(Q.symmetric(MatrixSlice(Y, (0, 1), (1, 2)))) is True
+    assert ask(Q.symmetric(Identity(3))) is True
+    assert ask(Q.symmetric(ZeroMatrix(3, 3))) is True
+    assert ask(Q.symmetric(OneMatrix(3, 3))) is True
+
+def _test_orthogonal_unitary(predicate):
+    assert ask(predicate(X), predicate(X))
+    assert ask(predicate(X.T), predicate(X)) is True
+    assert ask(predicate(X.I), predicate(X)) is True
+    assert ask(predicate(X**2), predicate(X))
+    assert ask(predicate(Y)) is False
+    assert ask(predicate(X)) is None
+    assert ask(predicate(X), ~Q.invertible(X)) is False
+    assert ask(predicate(X*Z*X), predicate(X) & predicate(Z)) is True
+    assert ask(predicate(Identity(3))) is True
+    assert ask(predicate(ZeroMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), predicate(X))
+    assert not ask(predicate(X + Z), predicate(X) & predicate(Z))
+
+def test_orthogonal():
+    _test_orthogonal_unitary(Q.orthogonal)
+
+def test_unitary():
+    _test_orthogonal_unitary(Q.unitary)
+    assert ask(Q.unitary(X), Q.orthogonal(X))
+
+def test_fullrank():
+    assert ask(Q.fullrank(X), Q.fullrank(X))
+    assert ask(Q.fullrank(X**2), Q.fullrank(X))
+    assert ask(Q.fullrank(X.T), Q.fullrank(X)) is True
+    assert ask(Q.fullrank(X)) is None
+    assert ask(Q.fullrank(Y)) is None
+    assert ask(Q.fullrank(X*Z), Q.fullrank(X) & Q.fullrank(Z)) is True
+    assert ask(Q.fullrank(Identity(3))) is True
+    assert ask(Q.fullrank(ZeroMatrix(3, 3))) is False
+    assert ask(Q.fullrank(OneMatrix(1, 1))) is True
+    assert ask(Q.fullrank(OneMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), ~Q.fullrank(X)) == False
+
+
+def test_positive_definite():
+    assert ask(Q.positive_definite(X), Q.positive_definite(X))
+    assert ask(Q.positive_definite(X.T), Q.positive_definite(X)) is True
+    assert ask(Q.positive_definite(X.I), Q.positive_definite(X)) is True
+    assert ask(Q.positive_definite(Y)) is False
+    assert ask(Q.positive_definite(X)) is None
+    assert ask(Q.positive_definite(X**3), Q.positive_definite(X))
+    assert ask(Q.positive_definite(X*Z*X),
+            Q.positive_definite(X) & Q.positive_definite(Z)) is True
+    assert ask(Q.positive_definite(X), Q.orthogonal(X))
+    assert ask(Q.positive_definite(Y.T*X*Y),
+            Q.positive_definite(X) & Q.fullrank(Y)) is True
+    assert not ask(Q.positive_definite(Y.T*X*Y), Q.positive_definite(X))
+    assert ask(Q.positive_definite(Identity(3))) is True
+    assert ask(Q.positive_definite(ZeroMatrix(3, 3))) is False
+    assert ask(Q.positive_definite(OneMatrix(1, 1))) is True
+    assert ask(Q.positive_definite(OneMatrix(3, 3))) is False
+    assert ask(Q.positive_definite(X + Z), Q.positive_definite(X) &
+            Q.positive_definite(Z)) is True
+    assert not ask(Q.positive_definite(-X), Q.positive_definite(X))
+    assert ask(Q.positive(X[1, 1]), Q.positive_definite(X))
+
+def test_triangular():
+    assert ask(Q.upper_triangular(X + Z.T + Identity(2)), Q.upper_triangular(X) &
+            Q.lower_triangular(Z)) is True
+    assert ask(Q.upper_triangular(X*Z.T), Q.upper_triangular(X) &
+            Q.lower_triangular(Z)) is True
+    assert ask(Q.lower_triangular(Identity(3))) is True
+    assert ask(Q.lower_triangular(ZeroMatrix(3, 3))) is True
+    assert ask(Q.upper_triangular(ZeroMatrix(3, 3))) is True
+    assert ask(Q.lower_triangular(OneMatrix(1, 1))) is True
+    assert ask(Q.upper_triangular(OneMatrix(1, 1))) is True
+    assert ask(Q.lower_triangular(OneMatrix(3, 3))) is False
+    assert ask(Q.upper_triangular(OneMatrix(3, 3))) is False
+    assert ask(Q.triangular(X), Q.unit_triangular(X))
+    assert ask(Q.upper_triangular(X**3), Q.upper_triangular(X))
+    assert ask(Q.lower_triangular(X**3), Q.lower_triangular(X))
+
+
+def test_diagonal():
+    assert ask(Q.diagonal(X + Z.T + Identity(2)), Q.diagonal(X) &
+               Q.diagonal(Z)) is True
+    assert ask(Q.diagonal(ZeroMatrix(3, 3)))
+    assert ask(Q.diagonal(OneMatrix(1, 1))) is True
+    assert ask(Q.diagonal(OneMatrix(3, 3))) is False
+    assert ask(Q.lower_triangular(X) & Q.upper_triangular(X), Q.diagonal(X))
+    assert ask(Q.diagonal(X), Q.lower_triangular(X) & Q.upper_triangular(X))
+    assert ask(Q.symmetric(X), Q.diagonal(X))
+    assert ask(Q.triangular(X), Q.diagonal(X))
+    assert ask(Q.diagonal(C0x0))
+    assert ask(Q.diagonal(A1x1))
+    assert ask(Q.diagonal(A1x1 + B1x1))
+    assert ask(Q.diagonal(A1x1*B1x1))
+    assert ask(Q.diagonal(V1.T*V2))
+    assert ask(Q.diagonal(V1.T*(X + Z)*V1))
+    assert ask(Q.diagonal(MatrixSlice(Y, (0, 1), (1, 2)))) is True
+    assert ask(Q.diagonal(V1.T*(V1 + V2))) is True
+    assert ask(Q.diagonal(X**3), Q.diagonal(X))
+    assert ask(Q.diagonal(Identity(3)))
+    assert ask(Q.diagonal(DiagMatrix(V1)))
+    assert ask(Q.diagonal(DiagonalMatrix(X)))
+
+
+def test_non_atoms():
+    assert ask(Q.real(Trace(X)), Q.positive(Trace(X)))
+
+@XFAIL
+def test_non_trivial_implies():
+    X = MatrixSymbol('X', 3, 3)
+    Y = MatrixSymbol('Y', 3, 3)
+    assert ask(Q.lower_triangular(X+Y), Q.lower_triangular(X) &
+               Q.lower_triangular(Y)) is True
+    assert ask(Q.triangular(X), Q.lower_triangular(X)) is True
+    assert ask(Q.triangular(X+Y), Q.lower_triangular(X) &
+               Q.lower_triangular(Y)) is True
+
+def test_MatrixSlice():
+    X = MatrixSymbol('X', 4, 4)
+    B = MatrixSlice(X, (1, 3), (1, 3))
+    C = MatrixSlice(X, (0, 3), (1, 3))
+    assert ask(Q.symmetric(B), Q.symmetric(X))
+    assert ask(Q.invertible(B), Q.invertible(X))
+    assert ask(Q.diagonal(B), Q.diagonal(X))
+    assert ask(Q.orthogonal(B), Q.orthogonal(X))
+    assert ask(Q.upper_triangular(B), Q.upper_triangular(X))
+
+    assert not ask(Q.symmetric(C), Q.symmetric(X))
+    assert not ask(Q.invertible(C), Q.invertible(X))
+    assert not ask(Q.diagonal(C), Q.diagonal(X))
+    assert not ask(Q.orthogonal(C), Q.orthogonal(X))
+    assert not ask(Q.upper_triangular(C), Q.upper_triangular(X))
+
+def test_det_trace_positive():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.positive(Trace(X)), Q.positive_definite(X))
+    assert ask(Q.positive(Determinant(X)), Q.positive_definite(X))
+
+def test_field_assumptions():
+    X = MatrixSymbol('X', 4, 4)
+    Y = MatrixSymbol('Y', 4, 4)
+    assert ask(Q.real_elements(X), Q.real_elements(X))
+    assert not ask(Q.integer_elements(X), Q.real_elements(X))
+    assert ask(Q.complex_elements(X), Q.real_elements(X))
+    assert ask(Q.complex_elements(X**2), Q.real_elements(X))
+    assert ask(Q.real_elements(X**2), Q.integer_elements(X))
+    assert ask(Q.real_elements(X+Y), Q.real_elements(X)) is None
+    assert ask(Q.real_elements(X+Y), Q.real_elements(X) & Q.real_elements(Y))
+    from sympy.matrices.expressions.hadamard import HadamardProduct
+    assert ask(Q.real_elements(HadamardProduct(X, Y)),
+                    Q.real_elements(X) & Q.real_elements(Y))
+    assert ask(Q.complex_elements(X+Y), Q.real_elements(X) & Q.complex_elements(Y))
+
+    assert ask(Q.real_elements(X.T), Q.real_elements(X))
+    assert ask(Q.real_elements(X.I), Q.real_elements(X) & Q.invertible(X))
+    assert ask(Q.real_elements(Trace(X)), Q.real_elements(X))
+    assert ask(Q.integer_elements(Determinant(X)), Q.integer_elements(X))
+    assert not ask(Q.integer_elements(X.I), Q.integer_elements(X))
+    alpha = Symbol('alpha')
+    assert ask(Q.real_elements(alpha*X), Q.real_elements(X) & Q.real(alpha))
+    assert ask(Q.real_elements(LofLU(X)), Q.real_elements(X))
+    e = Symbol('e', integer=True, negative=True)
+    assert ask(Q.real_elements(X**e), Q.real_elements(X) & Q.invertible(X))
+    assert ask(Q.real_elements(X**e), Q.real_elements(X)) is None
+
+def test_matrix_element_sets():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.real(X[1, 2]), Q.real_elements(X))
+    assert ask(Q.integer(X[1, 2]), Q.integer_elements(X))
+    assert ask(Q.complex(X[1, 2]), Q.complex_elements(X))
+    assert ask(Q.integer_elements(Identity(3)))
+    assert ask(Q.integer_elements(ZeroMatrix(3, 3)))
+    assert ask(Q.integer_elements(OneMatrix(3, 3)))
+    from sympy.matrices.expressions.fourier import DFT
+    assert ask(Q.complex_elements(DFT(3)))
+
+
+def test_matrix_element_sets_slices_blocks():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.integer_elements(X[:, 3]), Q.integer_elements(X))
+    assert ask(Q.integer_elements(BlockMatrix([[X], [X]])),
+                        Q.integer_elements(X))
+
+def test_matrix_element_sets_determinant_trace():
+    assert ask(Q.integer(Determinant(X)), Q.integer_elements(X))
+    assert ask(Q.integer(Trace(X)), Q.integer_elements(X))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_refine.py

@@ -0,0 +1,227 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.refine import refine
+from sympy.core.expr import Expr
+from sympy.core.numbers import (I, Rational, nan, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import (Abs, arg, im, re, sign)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan, atan2)
+from sympy.abc import w, x, y, z
+from sympy.core.relational import Eq, Ne
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+
+
+def test_Abs():
+    assert refine(Abs(x), Q.positive(x)) == x
+    assert refine(1 + Abs(x), Q.positive(x)) == 1 + x
+    assert refine(Abs(x), Q.negative(x)) == -x
+    assert refine(1 + Abs(x), Q.negative(x)) == 1 - x
+
+    assert refine(Abs(x**2)) != x**2
+    assert refine(Abs(x**2), Q.real(x)) == x**2
+
+
+def test_pow1():
+    assert refine((-1)**x, Q.even(x)) == 1
+    assert refine((-1)**x, Q.odd(x)) == -1
+    assert refine((-2)**x, Q.even(x)) == 2**x
+
+    # nested powers
+    assert refine(sqrt(x**2)) != Abs(x)
+    assert refine(sqrt(x**2), Q.complex(x)) != Abs(x)
+    assert refine(sqrt(x**2), Q.real(x)) == Abs(x)
+    assert refine(sqrt(x**2), Q.positive(x)) == x
+    assert refine((x**3)**Rational(1, 3)) != x
+
+    assert refine((x**3)**Rational(1, 3), Q.real(x)) != x
+    assert refine((x**3)**Rational(1, 3), Q.positive(x)) == x
+
+    assert refine(sqrt(1/x), Q.real(x)) != 1/sqrt(x)
+    assert refine(sqrt(1/x), Q.positive(x)) == 1/sqrt(x)
+
+    # powers of (-1)
+    assert refine((-1)**(x + y), Q.even(x)) == (-1)**y
+    assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y
+    assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y
+    assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1)
+    assert refine((-1)**(x + 3)) == (-1)**(x + 1)
+
+    # continuation
+    assert refine((-1)**((-1)**x/2 - S.Half), Q.integer(x)) == (-1)**x
+    assert refine((-1)**((-1)**x/2 + S.Half), Q.integer(x)) == (-1)**(x + 1)
+    assert refine((-1)**((-1)**x/2 + 5*S.Half), Q.integer(x)) == (-1)**(x + 1)
+
+
+def test_pow2():
+    assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1)
+    assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x
+
+    # powers of Abs
+    assert refine(Abs(x)**2, Q.real(x)) == x**2
+    assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3
+    assert refine(Abs(x)**2) == Abs(x)**2
+
+
+def test_exp():
+    x = Symbol('x', integer=True)
+    assert refine(exp(pi*I*2*x)) == 1
+    assert refine(exp(pi*I*2*(x + S.Half))) == -1
+    assert refine(exp(pi*I*2*(x + Rational(1, 4)))) == I
+    assert refine(exp(pi*I*2*(x + Rational(3, 4)))) == -I
+
+
+def test_Piecewise():
+    assert refine(Piecewise((1, x < 0), (3, True)), (x < 0)) == 1
+    assert refine(Piecewise((1, x < 0), (3, True)), ~(x < 0)) == 3
+    assert refine(Piecewise((1, x < 0), (3, True)), (y < 0)) == \
+        Piecewise((1, x < 0), (3, True))
+    assert refine(Piecewise((1, x > 0), (3, True)), (x > 0)) == 1
+    assert refine(Piecewise((1, x > 0), (3, True)), ~(x > 0)) == 3
+    assert refine(Piecewise((1, x > 0), (3, True)), (y > 0)) == \
+        Piecewise((1, x > 0), (3, True))
+    assert refine(Piecewise((1, x <= 0), (3, True)), (x <= 0)) == 1
+    assert refine(Piecewise((1, x <= 0), (3, True)), ~(x <= 0)) == 3
+    assert refine(Piecewise((1, x <= 0), (3, True)), (y <= 0)) == \
+        Piecewise((1, x <= 0), (3, True))
+    assert refine(Piecewise((1, x >= 0), (3, True)), (x >= 0)) == 1
+    assert refine(Piecewise((1, x >= 0), (3, True)), ~(x >= 0)) == 3
+    assert refine(Piecewise((1, x >= 0), (3, True)), (y >= 0)) == \
+        Piecewise((1, x >= 0), (3, True))
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(x, 0)))\
+        == 1
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(0, x)))\
+        == 1
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~(Eq(x, 0)))\
+        == 3
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~(Eq(0, x)))\
+        == 3
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(y, 0)))\
+        == Piecewise((1, Eq(x, 0)), (3, True))
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), (Ne(x, 0)))\
+        == 1
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), ~(Ne(x, 0)))\
+        == 3
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), (Ne(y, 0)))\
+        == Piecewise((1, Ne(x, 0)), (3, True))
+
+
+def test_atan2():
+    assert refine(atan2(y, x), Q.real(y) & Q.positive(x)) == atan(y/x)
+    assert refine(atan2(y, x), Q.negative(y) & Q.positive(x)) == atan(y/x)
+    assert refine(atan2(y, x), Q.negative(y) & Q.negative(x)) == atan(y/x) - pi
+    assert refine(atan2(y, x), Q.positive(y) & Q.negative(x)) == atan(y/x) + pi
+    assert refine(atan2(y, x), Q.zero(y) & Q.negative(x)) == pi
+    assert refine(atan2(y, x), Q.positive(y) & Q.zero(x)) == pi/2
+    assert refine(atan2(y, x), Q.negative(y) & Q.zero(x)) == -pi/2
+    assert refine(atan2(y, x), Q.zero(y) & Q.zero(x)) is nan
+
+
+def test_re():
+    assert refine(re(x), Q.real(x)) == x
+    assert refine(re(x), Q.imaginary(x)) is S.Zero
+    assert refine(re(x+y), Q.real(x) & Q.real(y)) == x + y
+    assert refine(re(x+y), Q.real(x) & Q.imaginary(y)) == x
+    assert refine(re(x*y), Q.real(x) & Q.real(y)) == x * y
+    assert refine(re(x*y), Q.real(x) & Q.imaginary(y)) == 0
+    assert refine(re(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) == x * y * z
+
+
+def test_im():
+    assert refine(im(x), Q.imaginary(x)) == -I*x
+    assert refine(im(x), Q.real(x)) is S.Zero
+    assert refine(im(x+y), Q.imaginary(x) & Q.imaginary(y)) == -I*x - I*y
+    assert refine(im(x+y), Q.real(x) & Q.imaginary(y)) == -I*y
+    assert refine(im(x*y), Q.imaginary(x) & Q.real(y)) == -I*x*y
+    assert refine(im(x*y), Q.imaginary(x) & Q.imaginary(y)) == 0
+    assert refine(im(1/x), Q.imaginary(x)) == -I/x
+    assert refine(im(x*y*z), Q.imaginary(x) & Q.imaginary(y)
+        & Q.imaginary(z)) == -I*x*y*z
+
+
+def test_complex():
+    assert refine(re(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
+        x/(x**2 + y**2)
+    assert refine(im(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
+        -y/(x**2 + y**2)
+    assert refine(re((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
+        & Q.real(z)) == w*y - x*z
+    assert refine(im((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
+        & Q.real(z)) == w*z + x*y
+
+
+def test_sign():
+    x = Symbol('x', real = True)
+    assert refine(sign(x), Q.positive(x)) == 1
+    assert refine(sign(x), Q.negative(x)) == -1
+    assert refine(sign(x), Q.zero(x)) == 0
+    assert refine(sign(x), True) == sign(x)
+    assert refine(sign(Abs(x)), Q.nonzero(x)) == 1
+
+    x = Symbol('x', imaginary=True)
+    assert refine(sign(x), Q.positive(im(x))) == S.ImaginaryUnit
+    assert refine(sign(x), Q.negative(im(x))) == -S.ImaginaryUnit
+    assert refine(sign(x), True) == sign(x)
+
+    x = Symbol('x', complex=True)
+    assert refine(sign(x), Q.zero(x)) == 0
+
+def test_arg():
+    x = Symbol('x', complex = True)
+    assert refine(arg(x), Q.positive(x)) == 0
+    assert refine(arg(x), Q.negative(x)) == pi
+
+def test_func_args():
+    class MyClass(Expr):
+        # A class with nontrivial .func
+
+        def __init__(self, *args):
+            self.my_member = ""
+
+        @property
+        def func(self):
+            def my_func(*args):
+                obj = MyClass(*args)
+                obj.my_member = self.my_member
+                return obj
+            return my_func
+
+    x = MyClass()
+    x.my_member = "A very important value"
+    assert x.my_member == refine(x).my_member
+
+def test_issue_refine_9384():
+    assert refine(Piecewise((1, x < 0), (0, True)), Q.positive(x)) == 0
+    assert refine(Piecewise((1, x < 0), (0, True)), Q.negative(x)) == 1
+    assert refine(Piecewise((1, x > 0), (0, True)), Q.positive(x)) == 1
+    assert refine(Piecewise((1, x > 0), (0, True)), Q.negative(x)) == 0
+
+
+def test_eval_refine():
+    class MockExpr(Expr):
+        def _eval_refine(self, assumptions):
+            return True
+
+    mock_obj = MockExpr()
+    assert refine(mock_obj)
+
+def test_refine_issue_12724():
+    expr1 = refine(Abs(x * y), Q.positive(x))
+    expr2 = refine(Abs(x * y * z), Q.positive(x))
+    assert expr1 == x * Abs(y)
+    assert expr2 == x * Abs(y * z)
+    y1 = Symbol('y1', real = True)
+    expr3 = refine(Abs(x * y1**2 * z), Q.positive(x))
+    assert expr3 == x * y1**2 * Abs(z)
+
+
+def test_matrixelement():
+    x = MatrixSymbol('x', 3, 3)
+    i = Symbol('i', positive = True)
+    j = Symbol('j', positive = True)
+    assert refine(x[0, 1], Q.symmetric(x)) == x[0, 1]
+    assert refine(x[1, 0], Q.symmetric(x)) == x[0, 1]
+    assert refine(x[i, j], Q.symmetric(x)) == x[j, i]
+    assert refine(x[j, i], Q.symmetric(x)) == x[j, i]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_rel_queries.py

@@ -0,0 +1,172 @@
+from sympy.assumptions.lra_satask import lra_satask
+from sympy.logic.algorithms.lra_theory import UnhandledInput
+from sympy.assumptions.ask import Q, ask
+
+from sympy.core import symbols, Symbol
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.core.numbers import I
+
+from sympy.testing.pytest import raises, XFAIL
+x, y, z = symbols("x y z", real=True)
+
+def test_lra_satask():
+    im = Symbol('im', imaginary=True)
+
+    # test preprocessing of unequalities is working correctly
+    assert lra_satask(Q.eq(x, 1), ~Q.ne(x, 0)) is False
+    assert lra_satask(Q.eq(x, 0), ~Q.ne(x, 0)) is True
+    assert lra_satask(~Q.ne(x, 0), Q.eq(x, 0)) is True
+    assert lra_satask(~Q.eq(x, 0), Q.eq(x, 0)) is False
+    assert lra_satask(Q.ne(x, 0), Q.eq(x, 0)) is False
+
+    # basic tests
+    assert lra_satask(Q.ne(x, x)) is False
+    assert lra_satask(Q.eq(x, x)) is True
+    assert lra_satask(Q.gt(x, 0), Q.gt(x, 1)) is True
+
+    # check that True/False are handled
+    assert lra_satask(Q.gt(x, 0), True) is None
+    assert raises(ValueError, lambda: lra_satask(Q.gt(x, 0), False))
+
+    # check imaginary numbers are correctly handled
+    # (im * I).is_real returns True so this is an edge case
+    raises(UnhandledInput, lambda: lra_satask(Q.gt(im * I, 0), Q.gt(im * I, 0)))
+
+    # check matrix inputs
+    X = MatrixSymbol("X", 2, 2)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(X, 2) & Q.gt(X, 3)))
+
+
+def test_old_assumptions():
+    # test unhandled old assumptions
+    w = symbols("w")
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", rational=False, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", odd=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", even=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", prime=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", composite=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", integer=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", integer=False, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+
+    # test handled
+    w = symbols("w", positive=True, real=True)
+    assert lra_satask(Q.le(w, 0)) is False
+    assert lra_satask(Q.gt(w, 0)) is True
+    w = symbols("w", negative=True, real=True)
+    assert lra_satask(Q.lt(w, 0)) is True
+    assert lra_satask(Q.ge(w, 0)) is False
+    w = symbols("w", zero=True, real=True)
+    assert lra_satask(Q.eq(w, 0)) is True
+    assert lra_satask(Q.ne(w, 0)) is False
+    w = symbols("w", nonzero=True, real=True)
+    assert lra_satask(Q.ne(w, 0)) is True
+    assert lra_satask(Q.eq(w, 1)) is None
+    w = symbols("w", nonpositive=True, real=True)
+    assert lra_satask(Q.le(w, 0)) is True
+    assert lra_satask(Q.gt(w, 0)) is False
+    w = symbols("w", nonnegative=True, real=True)
+    assert lra_satask(Q.ge(w, 0)) is True
+    assert lra_satask(Q.lt(w, 0)) is False
+
+
+def test_rel_queries():
+    assert ask(Q.lt(x, 2) & Q.gt(x, 3)) is False
+    assert ask(Q.positive(x - z), (x > y) & (y > z)) is True
+    assert ask(x + y > 2, (x < 0) & (y <0)) is False
+    assert ask(x > z, (x > y) & (y > z)) is True
+
+
+def test_unhandled_queries():
+    X = MatrixSymbol("X", 2, 2)
+    assert ask(Q.lt(X, 2) & Q.gt(X, 3)) is None
+
+
+def test_all_pred():
+    # test usable pred
+    assert lra_satask(Q.extended_positive(x), (x > 2)) is True
+    assert lra_satask(Q.positive_infinite(x)) is False
+    assert lra_satask(Q.negative_infinite(x)) is False
+
+    # test disallowed pred
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.prime(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.composite(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.odd(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.even(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.integer(x)))
+
+
+def test_number_line_properties():
+    # From:
+    # https://en.wikipedia.org/wiki/Inequality_(mathematics)#Properties_on_the_number_line
+
+    a, b, c = symbols("a b c", real=True)
+
+    # Transitivity
+    # If a <= b and b <= c, then a <= c.
+    assert ask(a <= c, (a <= b) & (b <= c)) is True
+    # If a <= b and b < c, then a < c.
+    assert ask(a < c, (a <= b) & (b < c)) is True
+    # If a < b and b <= c, then a < c.
+    assert ask(a < c, (a < b) & (b <= c)) is True
+
+    # Addition and subtraction
+    # If a <= b, then a + c <= b + c and a - c <= b - c.
+    assert ask(a + c <= b + c, a <= b) is True
+    assert ask(a - c <= b - c, a <= b) is True
+
+
+@XFAIL
+def test_failing_number_line_properties():
+    # From:
+    # https://en.wikipedia.org/wiki/Inequality_(mathematics)#Properties_on_the_number_line
+
+    a, b, c = symbols("a b c", real=True)
+
+    # Multiplication and division
+    # If a <= b and c > 0, then ac <= bc and a/c <= b/c. (True for non-zero c)
+    assert ask(a*c <= b*c, (a <= b) & (c > 0) & ~ Q.zero(c)) is True
+    assert ask(a/c <= b/c, (a <= b) & (c > 0) & ~ Q.zero(c)) is True
+    # If a <= b and c < 0, then ac >= bc and a/c >= b/c. (True for non-zero c)
+    assert ask(a*c >= b*c, (a <= b) & (c < 0) & ~ Q.zero(c)) is True
+    assert ask(a/c >= b/c, (a <= b) & (c < 0) & ~ Q.zero(c)) is True
+
+    # Additive inverse
+    # If a <= b, then -a >= -b.
+    assert ask(-a >= -b, a <= b) is True
+
+    # Multiplicative inverse
+    # For a, b that are both negative or both positive:
+    # If a <= b, then 1/a >= 1/b .
+    assert ask(1/a >= 1/b, (a <= b) & Q.positive(x) & Q.positive(b)) is True
+    assert ask(1/a >= 1/b, (a <= b) & Q.negative(x) & Q.negative(b)) is True
+
+
+def test_equality():
+    # test symmetry and reflexivity
+    assert ask(Q.eq(x, x)) is True
+    assert ask(Q.eq(y, x), Q.eq(x, y)) is True
+    assert ask(Q.eq(y, x), ~Q.eq(z, z) | Q.eq(x, y)) is True
+
+    # test transitivity
+    assert ask(Q.eq(x,z), Q.eq(x,y) & Q.eq(y,z)) is True
+
+
+@XFAIL
+def test_equality_failing():
+    # Note that implementing the substitution property of equality
+    # most likely requires a redesign of the new assumptions.
+    # See issue #25485 for why this is the case and general ideas
+    # about how things could be redesigned.
+
+    # test substitution property
+    assert ask(Q.prime(x), Q.eq(x, y) & Q.prime(y)) is True
+    assert ask(Q.real(x), Q.eq(x, y) & Q.real(y)) is True
+    assert ask(Q.imaginary(x), Q.eq(x, y) & Q.imaginary(y)) is True

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_satask.py

@@ -0,0 +1,378 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.assume import assuming
+from sympy.core.numbers import (I, pi)
+from sympy.core.relational import (Eq, Gt)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import Abs
+from sympy.logic.boolalg import Implies
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.assumptions.cnf import CNF, Literal
+from sympy.assumptions.satask import (satask, extract_predargs,
+    get_relevant_clsfacts)
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+x, y, z = symbols('x y z')
+
+
+def test_satask():
+    # No relevant facts
+    assert satask(Q.real(x), Q.real(x)) is True
+    assert satask(Q.real(x), ~Q.real(x)) is False
+    assert satask(Q.real(x)) is None
+
+    assert satask(Q.real(x), Q.positive(x)) is True
+    assert satask(Q.positive(x), Q.real(x)) is None
+    assert satask(Q.real(x), ~Q.positive(x)) is None
+    assert satask(Q.positive(x), ~Q.real(x)) is False
+
+    raises(ValueError, lambda: satask(Q.real(x), Q.real(x) & ~Q.real(x)))
+
+    with assuming(Q.positive(x)):
+        assert satask(Q.real(x)) is True
+        assert satask(~Q.positive(x)) is False
+        raises(ValueError, lambda: satask(Q.real(x), ~Q.positive(x)))
+
+    assert satask(Q.zero(x), Q.nonzero(x)) is False
+    assert satask(Q.positive(x), Q.zero(x)) is False
+    assert satask(Q.real(x), Q.zero(x)) is True
+    assert satask(Q.zero(x), Q.zero(x*y)) is None
+    assert satask(Q.zero(x*y), Q.zero(x))
+
+
+def test_zero():
+    """
+    Everything in this test doesn't work with the ask handlers, and most
+    things would be very difficult or impossible to make work under that
+    model.
+
+    """
+    assert satask(Q.zero(x) | Q.zero(y), Q.zero(x*y)) is True
+    assert satask(Q.zero(x*y), Q.zero(x) | Q.zero(y)) is True
+
+    assert satask(Implies(Q.zero(x), Q.zero(x*y))) is True
+
+    # This one in particular requires computing the fixed-point of the
+    # relevant facts, because going from Q.nonzero(x*y) -> ~Q.zero(x*y) and
+    # Q.zero(x*y) -> Equivalent(Q.zero(x*y), Q.zero(x) | Q.zero(y)) takes two
+    # steps.
+    assert satask(Q.zero(x) | Q.zero(y), Q.nonzero(x*y)) is False
+
+    assert satask(Q.zero(x), Q.zero(x**2)) is True
+
+
+def test_zero_positive():
+    assert satask(Q.zero(x + y), Q.positive(x) & Q.positive(y)) is False
+    assert satask(Q.positive(x) & Q.positive(y), Q.zero(x + y)) is False
+    assert satask(Q.nonzero(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.positive(x) & Q.positive(y), Q.nonzero(x + y)) is None
+
+    # This one requires several levels of forward chaining
+    assert satask(Q.zero(x*(x + y)), Q.positive(x) & Q.positive(y)) is False
+
+    assert satask(Q.positive(pi*x*y + 1), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.positive(pi*x*y - 5), Q.positive(x) & Q.positive(y)) is None
+
+
+def test_zero_pow():
+    assert satask(Q.zero(x**y), Q.zero(x) & Q.positive(y)) is True
+    assert satask(Q.zero(x**y), Q.nonzero(x) & Q.zero(y)) is False
+
+    assert satask(Q.zero(x), Q.zero(x**y)) is True
+
+    assert satask(Q.zero(x**y), Q.zero(x)) is None
+
+
+@XFAIL
+# Requires correct Q.square calculation first
+def test_invertible():
+    A = MatrixSymbol('A', 5, 5)
+    B = MatrixSymbol('B', 5, 5)
+    assert satask(Q.invertible(A*B), Q.invertible(A) & Q.invertible(B)) is True
+    assert satask(Q.invertible(A), Q.invertible(A*B)) is True
+    assert satask(Q.invertible(A) & Q.invertible(B), Q.invertible(A*B)) is True
+
+
+def test_prime():
+    assert satask(Q.prime(5)) is True
+    assert satask(Q.prime(6)) is False
+    assert satask(Q.prime(-5)) is False
+
+    assert satask(Q.prime(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert satask(Q.prime(x*y), Q.prime(x) & Q.prime(y)) is False
+
+
+def test_old_assump():
+    assert satask(Q.positive(1)) is True
+    assert satask(Q.positive(-1)) is False
+    assert satask(Q.positive(0)) is False
+    assert satask(Q.positive(I)) is False
+    assert satask(Q.positive(pi)) is True
+
+    assert satask(Q.negative(1)) is False
+    assert satask(Q.negative(-1)) is True
+    assert satask(Q.negative(0)) is False
+    assert satask(Q.negative(I)) is False
+    assert satask(Q.negative(pi)) is False
+
+    assert satask(Q.zero(1)) is False
+    assert satask(Q.zero(-1)) is False
+    assert satask(Q.zero(0)) is True
+    assert satask(Q.zero(I)) is False
+    assert satask(Q.zero(pi)) is False
+
+    assert satask(Q.nonzero(1)) is True
+    assert satask(Q.nonzero(-1)) is True
+    assert satask(Q.nonzero(0)) is False
+    assert satask(Q.nonzero(I)) is False
+    assert satask(Q.nonzero(pi)) is True
+
+    assert satask(Q.nonpositive(1)) is False
+    assert satask(Q.nonpositive(-1)) is True
+    assert satask(Q.nonpositive(0)) is True
+    assert satask(Q.nonpositive(I)) is False
+    assert satask(Q.nonpositive(pi)) is False
+
+    assert satask(Q.nonnegative(1)) is True
+    assert satask(Q.nonnegative(-1)) is False
+    assert satask(Q.nonnegative(0)) is True
+    assert satask(Q.nonnegative(I)) is False
+    assert satask(Q.nonnegative(pi)) is True
+
+
+def test_rational_irrational():
+    assert satask(Q.irrational(2)) is False
+    assert satask(Q.rational(2)) is True
+    assert satask(Q.irrational(pi)) is True
+    assert satask(Q.rational(pi)) is False
+    assert satask(Q.irrational(I)) is False
+    assert satask(Q.rational(I)) is False
+
+    assert satask(Q.irrational(x*y*z), Q.irrational(x) & Q.irrational(y) &
+        Q.rational(z)) is None
+    assert satask(Q.irrational(x*y*z), Q.irrational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+    assert satask(Q.irrational(pi*x*y), Q.rational(x) & Q.rational(y)) is True
+
+    assert satask(Q.irrational(x + y + z), Q.irrational(x) & Q.irrational(y) &
+        Q.rational(z)) is None
+    assert satask(Q.irrational(x + y + z), Q.irrational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+    assert satask(Q.irrational(pi + x + y), Q.rational(x) & Q.rational(y)) is True
+
+    assert satask(Q.irrational(x*y*z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is False
+    assert satask(Q.rational(x*y*z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+
+    assert satask(Q.irrational(x + y + z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is False
+    assert satask(Q.rational(x + y + z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+
+
+def test_even_satask():
+    assert satask(Q.even(2)) is True
+    assert satask(Q.even(3)) is False
+
+    assert satask(Q.even(x*y), Q.even(x) & Q.odd(y)) is True
+    assert satask(Q.even(x*y), Q.even(x) & Q.integer(y)) is True
+    assert satask(Q.even(x*y), Q.even(x) & Q.even(y)) is True
+    assert satask(Q.even(x*y), Q.odd(x) & Q.odd(y)) is False
+    assert satask(Q.even(x*y), Q.even(x)) is None
+    assert satask(Q.even(x*y), Q.odd(x) & Q.integer(y)) is None
+    assert satask(Q.even(x*y), Q.odd(x) & Q.odd(y)) is False
+
+    assert satask(Q.even(abs(x)), Q.even(x)) is True
+    assert satask(Q.even(abs(x)), Q.odd(x)) is False
+    assert satask(Q.even(x), Q.even(abs(x))) is None # x could be complex
+
+
+def test_odd_satask():
+    assert satask(Q.odd(2)) is False
+    assert satask(Q.odd(3)) is True
+
+    assert satask(Q.odd(x*y), Q.even(x) & Q.odd(y)) is False
+    assert satask(Q.odd(x*y), Q.even(x) & Q.integer(y)) is False
+    assert satask(Q.odd(x*y), Q.even(x) & Q.even(y)) is False
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+    assert satask(Q.odd(x*y), Q.even(x)) is None
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.integer(y)) is None
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+
+    assert satask(Q.odd(abs(x)), Q.even(x)) is False
+    assert satask(Q.odd(abs(x)), Q.odd(x)) is True
+    assert satask(Q.odd(x), Q.odd(abs(x))) is None # x could be complex
+
+
+def test_integer():
+    assert satask(Q.integer(1)) is True
+    assert satask(Q.integer(S.Half)) is False
+
+    assert satask(Q.integer(x + y), Q.integer(x) & Q.integer(y)) is True
+    assert satask(Q.integer(x + y), Q.integer(x)) is None
+
+    assert satask(Q.integer(x + y), Q.integer(x) & ~Q.integer(y)) is False
+    assert satask(Q.integer(x + y + z), Q.integer(x) & Q.integer(y) &
+        ~Q.integer(z)) is False
+    assert satask(Q.integer(x + y + z), Q.integer(x) & ~Q.integer(y) &
+        ~Q.integer(z)) is None
+    assert satask(Q.integer(x + y + z), Q.integer(x) & ~Q.integer(y)) is None
+    assert satask(Q.integer(x + y), Q.integer(x) & Q.irrational(y)) is False
+
+    assert satask(Q.integer(x*y), Q.integer(x) & Q.integer(y)) is True
+    assert satask(Q.integer(x*y), Q.integer(x)) is None
+
+    assert satask(Q.integer(x*y), Q.integer(x) & ~Q.integer(y)) is None
+    assert satask(Q.integer(x*y), Q.integer(x) & ~Q.rational(y)) is False
+    assert satask(Q.integer(x*y*z), Q.integer(x) & Q.integer(y) &
+        ~Q.rational(z)) is False
+    assert satask(Q.integer(x*y*z), Q.integer(x) & ~Q.rational(y) &
+        ~Q.rational(z)) is None
+    assert satask(Q.integer(x*y*z), Q.integer(x) & ~Q.rational(y)) is None
+    assert satask(Q.integer(x*y), Q.integer(x) & Q.irrational(y)) is False
+
+
+def test_abs():
+    assert satask(Q.nonnegative(abs(x))) is True
+    assert satask(Q.positive(abs(x)), ~Q.zero(x)) is True
+    assert satask(Q.zero(x), ~Q.zero(abs(x))) is False
+    assert satask(Q.zero(x), Q.zero(abs(x))) is True
+    assert satask(Q.nonzero(x), ~Q.zero(abs(x))) is None # x could be complex
+    assert satask(Q.zero(abs(x)), Q.zero(x)) is True
+
+
+def test_imaginary():
+    assert satask(Q.imaginary(2*I)) is True
+    assert satask(Q.imaginary(x*y), Q.imaginary(x)) is None
+    assert satask(Q.imaginary(x*y), Q.imaginary(x) & Q.real(y)) is True
+    assert satask(Q.imaginary(x), Q.real(x)) is False
+    assert satask(Q.imaginary(1)) is False
+    assert satask(Q.imaginary(x*y), Q.real(x) & Q.real(y)) is False
+    assert satask(Q.imaginary(x + y), Q.real(x) & Q.real(y)) is False
+
+
+def test_real():
+    assert satask(Q.real(x*y), Q.real(x) & Q.real(y)) is True
+    assert satask(Q.real(x + y), Q.real(x) & Q.real(y)) is True
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y)) is None
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y) & Q.imaginary(z)) is False
+    assert satask(Q.real(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert satask(Q.real(x + y + z), Q.real(x) & Q.real(y)) is None
+
+
+def test_pos_neg():
+    assert satask(~Q.positive(x), Q.negative(x)) is True
+    assert satask(~Q.negative(x), Q.positive(x)) is True
+    assert satask(Q.positive(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.negative(x + y), Q.negative(x) & Q.negative(y)) is True
+    assert satask(Q.positive(x + y), Q.negative(x) & Q.negative(y)) is False
+    assert satask(Q.negative(x + y), Q.positive(x) & Q.positive(y)) is False
+
+
+def test_pow_pos_neg():
+    assert satask(Q.nonnegative(x**2), Q.positive(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.positive(x)) is False
+    assert satask(Q.positive(x**2), Q.positive(x)) is True
+    assert satask(Q.negative(x**2), Q.positive(x)) is False
+    assert satask(Q.real(x**2), Q.positive(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.negative(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.negative(x)) is False
+    assert satask(Q.positive(x**2), Q.negative(x)) is True
+    assert satask(Q.negative(x**2), Q.negative(x)) is False
+    assert satask(Q.real(x**2), Q.negative(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.nonnegative(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.nonnegative(x)) is None
+    assert satask(Q.positive(x**2), Q.nonnegative(x)) is None
+    assert satask(Q.negative(x**2), Q.nonnegative(x)) is False
+    assert satask(Q.real(x**2), Q.nonnegative(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.nonpositive(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.nonpositive(x)) is None
+    assert satask(Q.positive(x**2), Q.nonpositive(x)) is None
+    assert satask(Q.negative(x**2), Q.nonpositive(x)) is False
+    assert satask(Q.real(x**2), Q.nonpositive(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.positive(x)) is True
+    assert satask(Q.nonpositive(x**3), Q.positive(x)) is False
+    assert satask(Q.positive(x**3), Q.positive(x)) is True
+    assert satask(Q.negative(x**3), Q.positive(x)) is False
+    assert satask(Q.real(x**3), Q.positive(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.negative(x)) is False
+    assert satask(Q.nonpositive(x**3), Q.negative(x)) is True
+    assert satask(Q.positive(x**3), Q.negative(x)) is False
+    assert satask(Q.negative(x**3), Q.negative(x)) is True
+    assert satask(Q.real(x**3), Q.negative(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.nonnegative(x)) is True
+    assert satask(Q.nonpositive(x**3), Q.nonnegative(x)) is None
+    assert satask(Q.positive(x**3), Q.nonnegative(x)) is None
+    assert satask(Q.negative(x**3), Q.nonnegative(x)) is False
+    assert satask(Q.real(x**3), Q.nonnegative(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.nonpositive(x)) is None
+    assert satask(Q.nonpositive(x**3), Q.nonpositive(x)) is True
+    assert satask(Q.positive(x**3), Q.nonpositive(x)) is False
+    assert satask(Q.negative(x**3), Q.nonpositive(x)) is None
+    assert satask(Q.real(x**3), Q.nonpositive(x)) is True
+
+    # If x is zero, x**negative is not real.
+    assert satask(Q.nonnegative(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.nonpositive(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.positive(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.negative(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.real(x**-2), Q.nonpositive(x)) is None
+
+    # We could deduce things for negative powers if x is nonzero, but it
+    # isn't implemented yet.
+
+
+def test_prime_composite():
+    assert satask(Q.prime(x), Q.composite(x)) is False
+    assert satask(Q.composite(x), Q.prime(x)) is False
+    assert satask(Q.composite(x), ~Q.prime(x)) is None
+    assert satask(Q.prime(x), ~Q.composite(x)) is None
+    # since 1 is neither prime nor composite the following should hold
+    assert satask(Q.prime(x), Q.integer(x) & Q.positive(x) & ~Q.composite(x)) is None
+    assert satask(Q.prime(2)) is True
+    assert satask(Q.prime(4)) is False
+    assert satask(Q.prime(1)) is False
+    assert satask(Q.composite(1)) is False
+
+
+def test_extract_predargs():
+    props = CNF.from_prop(Q.zero(Abs(x*y)) & Q.zero(x*y))
+    assump = CNF.from_prop(Q.zero(x))
+    context = CNF.from_prop(Q.zero(y))
+    assert extract_predargs(props) == {Abs(x*y), x*y}
+    assert extract_predargs(props, assump) == {Abs(x*y), x*y, x}
+    assert extract_predargs(props, assump, context) == {Abs(x*y), x*y, x, y}
+
+    props = CNF.from_prop(Eq(x, y))
+    assump = CNF.from_prop(Gt(y, z))
+    assert extract_predargs(props, assump) == {x, y, z}
+
+
+def test_get_relevant_clsfacts():
+    exprs = {Abs(x*y)}
+    exprs, facts = get_relevant_clsfacts(exprs)
+    assert exprs == {x*y}
+    assert facts.clauses == \
+        {frozenset({Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}),
+        frozenset({Literal(Q.zero(Abs(x*y)), False), Literal(Q.zero(x*y), True)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True)}),
+        frozenset({Literal(Q.zero(Abs(x*y)), True), Literal(Q.zero(x*y), False)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False),
+                    Literal(Q.odd(Abs(x*y)), False),
+                    Literal(Q.odd(x*y), True)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False),
+                    Literal(Q.even(x*y), True),
+                    Literal(Q.odd(Abs(x*y)), False)}),
+        frozenset({Literal(Q.positive(Abs(x*y)), False),
+                    Literal(Q.zero(Abs(x*y)), False)})}

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_sathandlers.py

@@ -0,0 +1,50 @@
+from sympy.assumptions.ask import Q
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.symbol import symbols
+from sympy.logic.boolalg import (And, Or)
+
+from sympy.assumptions.sathandlers import (ClassFactRegistry, allargs,
+    anyarg, exactlyonearg,)
+
+x, y, z = symbols('x y z')
+
+
+def test_class_handler_registry():
+    my_handler_registry = ClassFactRegistry()
+
+    # The predicate doesn't matter here, so just pass
+    @my_handler_registry.register(Mul)
+    def fact1(expr):
+        pass
+    @my_handler_registry.multiregister(Expr)
+    def fact2(expr):
+        pass
+
+    assert my_handler_registry[Basic] == (frozenset(), frozenset())
+    assert my_handler_registry[Expr] == (frozenset(), frozenset({fact2}))
+    assert my_handler_registry[Mul] == (frozenset({fact1}), frozenset({fact2}))
+
+
+def test_allargs():
+    assert allargs(x, Q.zero(x), x*y) == And(Q.zero(x), Q.zero(y))
+    assert allargs(x, Q.positive(x) | Q.negative(x), x*y) == And(Q.positive(x) | Q.negative(x), Q.positive(y) | Q.negative(y))
+
+
+def test_anyarg():
+    assert anyarg(x, Q.zero(x), x*y) == Or(Q.zero(x), Q.zero(y))
+    assert anyarg(x, Q.positive(x) & Q.negative(x), x*y) == \
+        Or(Q.positive(x) & Q.negative(x), Q.positive(y) & Q.negative(y))
+
+
+def test_exactlyonearg():
+    assert exactlyonearg(x, Q.zero(x), x*y) == \
+        Or(Q.zero(x) & ~Q.zero(y), Q.zero(y) & ~Q.zero(x))
+    assert exactlyonearg(x, Q.zero(x), x*y*z) == \
+        Or(Q.zero(x) & ~Q.zero(y) & ~Q.zero(z), Q.zero(y)
+        & ~Q.zero(x) & ~Q.zero(z), Q.zero(z) & ~Q.zero(x) & ~Q.zero(y))
+    assert exactlyonearg(x, Q.positive(x) | Q.negative(x), x*y) == \
+        Or((Q.positive(x) | Q.negative(x)) &
+        ~(Q.positive(y) | Q.negative(y)), (Q.positive(y) | Q.negative(y)) &
+        ~(Q.positive(x) | Q.negative(x)))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/assumptions/tests/test_wrapper.py

@@ -0,0 +1,39 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.wrapper import (AssumptionsWrapper, is_infinite,
+    is_extended_real)
+from sympy.core.symbol import Symbol
+from sympy.core.assumptions import _assume_defined
+
+
+def test_all_predicates():
+    for fact in _assume_defined:
+        method_name = f'_eval_is_{fact}'
+        assert hasattr(AssumptionsWrapper, method_name)
+
+
+def test_AssumptionsWrapper():
+    x = Symbol('x', positive=True)
+    y = Symbol('y')
+    assert AssumptionsWrapper(x).is_positive
+    assert AssumptionsWrapper(y).is_positive is None
+    assert AssumptionsWrapper(y, Q.positive(y)).is_positive
+
+
+def test_is_infinite():
+    x = Symbol('x', infinite=True)
+    y = Symbol('y', infinite=False)
+    z = Symbol('z')
+    assert is_infinite(x)
+    assert not is_infinite(y)
+    assert is_infinite(z) is None
+    assert is_infinite(z, Q.infinite(z))
+
+
+def test_is_extended_real():
+    x = Symbol('x', extended_real=True)
+    y = Symbol('y', extended_real=False)
+    z = Symbol('z')
+    assert is_extended_real(x)
+    assert not is_extended_real(y)
+    assert is_extended_real(z) is None
+    assert is_extended_real(z, Q.extended_real(z))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/benchmarks/bench_discrete_log.py

@@ -0,0 +1,83 @@
+import sys
+from time import time
+from sympy.ntheory.residue_ntheory import (discrete_log,
+        _discrete_log_trial_mul, _discrete_log_shanks_steps,
+        _discrete_log_pollard_rho, _discrete_log_pohlig_hellman)
+
+
+# Cyclic group (Z/pZ)* with p prime, order p - 1 and generator g
+data_set_1 = [
+        # p, p - 1, g
+        [191, 190, 19],
+        [46639, 46638, 6],
+        [14789363, 14789362, 2],
+        [4254225211, 4254225210, 2],
+        [432751500361, 432751500360, 7],
+        [158505390797053, 158505390797052, 2],
+        [6575202655312007, 6575202655312006, 5],
+        [8430573471995353769, 8430573471995353768, 3],
+        [3938471339744997827267, 3938471339744997827266, 2],
+        [875260951364705563393093, 875260951364705563393092, 5],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with prime order p and generator g
+# (n, p are primes and n = 2 * p + 1)
+data_set_2 = [
+        # n, p, g
+        [227, 113, 3],
+        [2447, 1223, 2],
+        [24527, 12263, 2],
+        [245639, 122819, 2],
+        [2456747, 1228373, 3],
+        [24567899, 12283949, 3],
+        [245679023, 122839511, 2],
+        [2456791307, 1228395653, 3],
+        [24567913439, 12283956719, 2],
+        [245679135407, 122839567703, 2],
+        [2456791354763, 1228395677381, 3],
+        [24567913550903, 12283956775451, 2],
+        [245679135509519, 122839567754759, 2],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with smooth order o and generator g
+data_set_3 = [
+        # n, o, g
+        [2**118, 2**116, 3],
+    ]
+
+
+def bench_discrete_log(data_set, algo=None):
+    if algo is None:
+        f = discrete_log
+    elif algo == 'trial':
+        f = _discrete_log_trial_mul
+    elif algo == 'shanks':
+        f = _discrete_log_shanks_steps
+    elif algo == 'rho':
+        f = _discrete_log_pollard_rho
+    elif algo == 'ph':
+        f = _discrete_log_pohlig_hellman
+    else:
+        raise ValueError("Argument 'algo' should be one"
+                " of ('trial', 'shanks', 'rho' or 'ph')")
+
+    for i, data in enumerate(data_set):
+        for j, (n, p, g) in enumerate(data):
+            t = time()
+            l = f(n, pow(g, p - 1, n), g, p)
+            t = time() - t
+            print('[%02d-%03d] %15.10f' % (i, j, t))
+            assert l == p - 1
+
+
+if __name__ == '__main__':
+    algo = sys.argv[1] \
+            if len(sys.argv) > 1 else None
+    data_set = [
+            data_set_1,
+            data_set_2,
+            data_set_3,
+        ]
+    bench_discrete_log(data_set, algo)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/benchmarks/bench_meijerint.py

@@ -0,0 +1,261 @@
+# conceal the implicit import from the code quality tester
+from sympy.core.numbers import (oo, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate
+from sympy.integrals.transforms import (mellin_transform,
+    inverse_fourier_transform, inverse_mellin_transform,
+    laplace_transform, inverse_laplace_transform, fourier_transform)
+
+LT = laplace_transform
+FT = fourier_transform
+MT = mellin_transform
+IFT = inverse_fourier_transform
+ILT = inverse_laplace_transform
+IMT = inverse_mellin_transform
+
+from sympy.abc import x, y
+nu, beta, rho = symbols('nu beta rho')
+
+apos, bpos, cpos, dpos, posk, p = symbols('a b c d k p', positive=True)
+k = Symbol('k', real=True)
+negk = Symbol('k', negative=True)
+
+mu1, mu2 = symbols('mu1 mu2', real=True, nonzero=True, finite=True)
+sigma1, sigma2 = symbols('sigma1 sigma2', real=True, nonzero=True,
+                         finite=True, positive=True)
+rate = Symbol('lambda', positive=True)
+
+
+def normal(x, mu, sigma):
+    return 1/sqrt(2*pi*sigma**2)*exp(-(x - mu)**2/2/sigma**2)
+
+
+def exponential(x, rate):
+    return rate*exp(-rate*x)
+alpha, beta = symbols('alpha beta', positive=True)
+betadist = x**(alpha - 1)*(1 + x)**(-alpha - beta)*gamma(alpha + beta) \
+    /gamma(alpha)/gamma(beta)
+kint = Symbol('k', integer=True, positive=True)
+chi = 2**(1 - kint/2)*x**(kint - 1)*exp(-x**2/2)/gamma(kint/2)
+chisquared = 2**(-k/2)/gamma(k/2)*x**(k/2 - 1)*exp(-x/2)
+dagum = apos*p/x*(x/bpos)**(apos*p)/(1 + x**apos/bpos**apos)**(p + 1)
+d1, d2 = symbols('d1 d2', positive=True)
+f = sqrt(((d1*x)**d1 * d2**d2)/(d1*x + d2)**(d1 + d2))/x \
+    /gamma(d1/2)/gamma(d2/2)*gamma((d1 + d2)/2)
+nupos, sigmapos = symbols('nu sigma', positive=True)
+rice = x/sigmapos**2*exp(-(x**2 + nupos**2)/2/sigmapos**2)*besseli(0, x*
+                         nupos/sigmapos**2)
+mu = Symbol('mu', real=True)
+laplace = exp(-abs(x - mu)/bpos)/2/bpos
+
+u = Symbol('u', polar=True)
+tpos = Symbol('t', positive=True)
+
+
+def E(expr):
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (x, 0, oo), (y, -oo, oo), meijerg=True)
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (y, -oo, oo), (x, 0, oo), meijerg=True)
+
+bench = [
+    'MT(x**nu*Heaviside(x - 1), x, s)',
+    'MT(x**nu*Heaviside(1 - x), x, s)',
+    'MT((1-x)**(beta - 1)*Heaviside(1-x), x, s)',
+    'MT((x-1)**(beta - 1)*Heaviside(x-1), x, s)',
+    'MT((1+x)**(-rho), x, s)',
+    'MT(abs(1-x)**(-rho), x, s)',
+    'MT((1-x)**(beta-1)*Heaviside(1-x) + a*(x-1)**(beta-1)*Heaviside(x-1), x, s)',
+    'MT((x**a-b**a)/(x-b), x, s)',
+    'MT((x**a-bpos**a)/(x-bpos), x, s)',
+    'MT(exp(-x), x, s)',
+    'MT(exp(-1/x), x, s)',
+    'MT(log(x)**4*Heaviside(1-x), x, s)',
+    'MT(log(x)**3*Heaviside(x-1), x, s)',
+    'MT(log(x + 1), x, s)',
+    'MT(log(1/x + 1), x, s)',
+    'MT(log(abs(1 - x)), x, s)',
+    'MT(log(abs(1 - 1/x)), x, s)',
+    'MT(log(x)/(x+1), x, s)',
+    'MT(log(x)**2/(x+1), x, s)',
+    'MT(log(x)/(x+1)**2, x, s)',
+    'MT(erf(sqrt(x)), x, s)',
+
+    'MT(besselj(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2, x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(-a, sqrt(x)), x, s)',
+    'MT(besselj(a - 1, sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(b, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2 + besselj(-a, sqrt(x))**2, x, s)',
+    'MT(bessely(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(b, sqrt(x)), x, s)',
+    'MT(bessely(a, sqrt(x))**2, x, s)',
+
+    'MT(besselk(a, 2*sqrt(x)), x, s)',
+    'MT(besselj(a, 2*sqrt(2*sqrt(x)))*besselk(a, 2*sqrt(2*sqrt(x))), x, s)',
+    'MT(besseli(a, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(besseli(b, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(exp(-x/2)*besselk(a, x/2), x, s)',
+
+    # later: ILT, IMT
+
+    'LT((t-apos)**bpos*exp(-cpos*(t-apos))*Heaviside(t-apos), t, s)',
+    'LT(t**apos, t, s)',
+    'LT(Heaviside(t), t, s)',
+    'LT(Heaviside(t - apos), t, s)',
+    'LT(1 - exp(-apos*t), t, s)',
+    'LT((exp(2*t)-1)*exp(-bpos - t)*Heaviside(t)/2, t, s, noconds=True)',
+    'LT(exp(t), t, s)',
+    'LT(exp(2*t), t, s)',
+    'LT(exp(apos*t), t, s)',
+    'LT(log(t/apos), t, s)',
+    'LT(erf(t), t, s)',
+    'LT(sin(apos*t), t, s)',
+    'LT(cos(apos*t), t, s)',
+    'LT(exp(-apos*t)*sin(bpos*t), t, s)',
+    'LT(exp(-apos*t)*cos(bpos*t), t, s)',
+    'LT(besselj(0, t), t, s, noconds=True)',
+    'LT(besselj(1, t), t, s, noconds=True)',
+
+    'FT(Heaviside(1 - abs(2*apos*x)), x, k)',
+    'FT(Heaviside(1-abs(apos*x))*(1-abs(apos*x)), x, k)',
+    'FT(exp(-apos*x)*Heaviside(x), x, k)',
+    'IFT(1/(apos + 2*pi*I*x), x, posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, -posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, negk)',
+    'FT(x*exp(-apos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x)*sin(bpos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x**2), x, k)',
+    'IFT(sqrt(pi/apos)*exp(-(pi*k)**2/apos), k, x)',
+    'FT(exp(-apos*abs(x)), x, k)',
+
+    'integrate(normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**3*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y+1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y-1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                   (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x**2*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'E(1)',
+    'E(x*y)',
+    'E(x*y**2)',
+    'E((x+y+1)**2)',
+    'E(x+y+1)',
+    'E((x+y-1)**2)',
+    'integrate(betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(chi, (x, 0, oo), meijerg=True)',
+    'integrate(x*chi, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chi, (x, 0, oo), meijerg=True)',
+    'integrate(chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(((x-k)/sqrt(2*k))**3*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(f, (x, 0, oo), meijerg=True)',
+    'integrate(x*f, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*f, (x, 0, oo), meijerg=True)',
+    'integrate(rice, (x, 0, oo), meijerg=True)',
+    'integrate(laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(log(x) * x**(k-1) * exp(-x) / gamma(k), (x, 0, oo))',
+
+    'integrate(sin(z*x)*(x**2-1)**(-(y+S(1)/2)), (x, 1, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*besselk(0,x), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(a,x)*besselj(b,x)/x, (x,0,oo), meijerg=True)',
+
+    'hyperexpand(meijerg((-s - a/2 + 1, -s + a/2 + 1), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), (a/2, -a/2), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), 1))',
+    "gammasimp(S('2**(2*s)*(-pi*gamma(-a + 1)*gamma(a + 1)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 3/2)*gamma(a + s + 1)/(a*(a + s)) - gamma(-a - 1/2)*gamma(-a + 1)*gamma(a + 1)*gamma(a + 3/2)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a + s + 1)*gamma(a - s + 1)/(a*(-a + s)))*gamma(-2*s + 1)*gamma(s + 1)/(pi*s*gamma(-a - 1/2)*gamma(a + 3/2)*gamma(-s + 1)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 1)*gamma(a - s + 3/2))'))",
+
+    'mellin_transform(E1(x), x, s)',
+    'inverse_mellin_transform(gamma(s)/s, s, x, (0, oo))',
+    'mellin_transform(expint(a, x), x, s)',
+    'mellin_transform(Si(x), x, s)',
+    'inverse_mellin_transform(-2**s*sqrt(pi)*gamma((s + 1)/2)/(2*s*gamma(-s/2 + 1)), s, x, (-1, 0))',
+    'mellin_transform(Ci(sqrt(x)), x, s)',
+    'inverse_mellin_transform(-4**s*sqrt(pi)*gamma(s)/(2*s*gamma(-s + S(1)/2)),s, u, (0, 1))',
+    'laplace_transform(Ci(x), x, s)',
+    'laplace_transform(expint(a, x), x, s)',
+    'laplace_transform(expint(1, x), x, s)',
+    'laplace_transform(expint(2, x), x, s)',
+    'inverse_laplace_transform(-log(1 + s**2)/2/s, s, u)',
+    'inverse_laplace_transform(log(s + 1)/s, s, x)',
+    'inverse_laplace_transform((s - log(s + 1))/s**2, s, x)',
+    'laplace_transform(Chi(x), x, s)',
+    'laplace_transform(Shi(x), x, s)',
+
+    'integrate(exp(-z*x)/x, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**2, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**3, (x, 1, oo), meijerg=True,conds="none")',
+    'integrate(-cos(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(-sin(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(sin(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(sinh(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(exp(-x)/x, x, meijerg=True)',
+    'integrate(exp(-x)/x**2, x, meijerg=True)',
+    'integrate(cos(u)/u, u, meijerg=True)',
+    'integrate(cosh(u)/u, u, meijerg=True)',
+    'integrate(expint(1, x), x, meijerg=True)',
+    'integrate(expint(2, x), x, meijerg=True)',
+    'integrate(Si(x), x, meijerg=True)',
+    'integrate(Ci(u), u, meijerg=True)',
+    'integrate(Shi(x), x, meijerg=True)',
+    'integrate(Chi(u), u, meijerg=True)',
+    'integrate(Si(x)*exp(-x), (x, 0, oo), meijerg=True)',
+    'integrate(expint(1, x)*sin(x), (x, 0, oo), meijerg=True)'
+]
+
+from time import time
+from sympy.core.cache import clear_cache
+import sys
+
+timings = []
+
+if __name__ == '__main__':
+    for n, string in enumerate(bench):
+        clear_cache()
+        _t = time()
+        exec(string)
+        _t = time() - _t
+        timings += [(_t, string)]
+        sys.stdout.write('.')
+        sys.stdout.flush()
+        if n % (len(bench) // 10) == 0:
+            sys.stdout.write('%s' % (10*n // len(bench)))
+    print()
+
+    timings.sort(key=lambda x: -x[0])
+
+    for ti, string in timings:
+        print('%.2fs %s' % (ti, string))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/benchmarks/bench_symbench.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+from sympy.core.random import random
+from sympy.core.numbers import (I, Integer, pi)
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import factor
+from sympy.simplify.simplify import simplify
+from sympy.abc import x, y, z
+from timeit import default_timer as clock
+
+
+def bench_R1():
+    "real(f(f(f(f(f(f(f(f(f(f(i/2)))))))))))"
+    def f(z):
+        return sqrt(Integer(1)/3)*z**2 + I/3
+    f(f(f(f(f(f(f(f(f(f(I/2)))))))))).as_real_imag()[0]
+
+
+def bench_R2():
+    "Hermite polynomial hermite(15, y)"
+    def hermite(n, y):
+        if n == 1:
+            return 2*y
+        if n == 0:
+            return 1
+        return (2*y*hermite(n - 1, y) - 2*(n - 1)*hermite(n - 2, y)).expand()
+
+    hermite(15, y)
+
+
+def bench_R3():
+    "a = [bool(f==f) for _ in range(10)]"
+    f = x + y + z
+    [bool(f == f) for _ in range(10)]
+
+
+def bench_R4():
+    # we don't have Tuples
+    pass
+
+
+def bench_R5():
+    "blowup(L, 8); L=uniq(L)"
+    def blowup(L, n):
+        for i in range(n):
+            L.append( (L[i] + L[i + 1]) * L[i + 2] )
+
+    def uniq(x):
+        v = set(x)
+        return v
+    L = [x, y, z]
+    blowup(L, 8)
+    L = uniq(L)
+
+
+def bench_R6():
+    "sum(simplify((x+sin(i))/x+(x-sin(i))/x) for i in range(100))"
+    sum(simplify((x + sin(i))/x + (x - sin(i))/x) for i in range(100))
+
+
+def bench_R7():
+    "[f.subs(x, random()) for _ in range(10**4)]"
+    f = x**24 + 34*x**12 + 45*x**3 + 9*x**18 + 34*x**10 + 32*x**21
+    [f.subs(x, random()) for _ in range(10**4)]
+
+
+def bench_R8():
+    "right(x^2,0,5,10^4)"
+    def right(f, a, b, n):
+        a = sympify(a)
+        b = sympify(b)
+        n = sympify(n)
+        x = f.atoms(Symbol).pop()
+        Deltax = (b - a)/n
+        c = a
+        est = 0
+        for i in range(n):
+            c += Deltax
+            est += f.subs(x, c)
+        return est*Deltax
+
+    right(x**2, 0, 5, 10**4)
+
+
+def _bench_R9():
+    "factor(x^20 - pi^5*y^20)"
+    factor(x**20 - pi**5*y**20)
+
+
+def bench_R10():
+    "v = [-pi,-pi+1/10..,pi]"
+    def srange(min, max, step):
+        v = [min]
+        while (max - v[-1]).evalf() > 0:
+            v.append(v[-1] + step)
+        return v[:-1]
+    srange(-pi, pi, sympify(1)/10)
+
+
+def bench_R11():
+    "a = [random() + random()*I for w in [0..1000]]"
+    [random() + random()*I for w in range(1000)]
+
+
+def bench_S1():
+    "e=(x+y+z+1)**7;f=e*(e+1);f.expand()"
+    e = (x + y + z + 1)**7
+    f = e*(e + 1)
+    f.expand()
+
+
+if __name__ == '__main__':
+    benchmarks = [
+        bench_R1,
+        bench_R2,
+        bench_R3,
+        bench_R5,
+        bench_R6,
+        bench_R7,
+        bench_R8,
+        #_bench_R9,
+        bench_R10,
+        bench_R11,
+        #bench_S1,
+    ]
+
+    report = []
+    for b in benchmarks:
+        t = clock()
+        b()
+        t = clock() - t
+        print("%s%65s: %f" % (b.__name__, b.__doc__, t))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/__init__.py

@@ -0,0 +1,25 @@
+"""Calculus-related methods."""
+
+from .euler import euler_equations
+from .singularities import (singularities, is_increasing,
+                            is_strictly_increasing, is_decreasing,
+                            is_strictly_decreasing, is_monotonic)
+from .finite_diff import finite_diff_weights, apply_finite_diff, differentiate_finite
+from .util import (periodicity, not_empty_in, is_convex,
+                   stationary_points, minimum, maximum)
+from .accumulationbounds import AccumBounds
+
+__all__ = [
+'euler_equations',
+
+'singularities', 'is_increasing',
+'is_strictly_increasing', 'is_decreasing',
+'is_strictly_decreasing', 'is_monotonic',
+
+'finite_diff_weights', 'apply_finite_diff', 'differentiate_finite',
+
+'periodicity', 'not_empty_in', 'is_convex', 'stationary_points',
+'minimum', 'maximum',
+
+'AccumBounds'
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/accumulationbounds.py

@@ -0,0 +1,804 @@
+from sympy.core import Add, Mul, Pow, S
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.numbers import _sympifyit, oo, zoo
+from sympy.core.relational import is_le, is_lt, is_ge, is_gt
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.logic.boolalg import And
+from sympy.multipledispatch import dispatch
+from sympy.series.order import Order
+from sympy.sets.sets import FiniteSet
+
+
+class AccumulationBounds(Expr):
+    r"""An accumulation bounds.
+
+    # Note AccumulationBounds has an alias: AccumBounds
+
+    AccumulationBounds represent an interval `[a, b]`, which is always closed
+    at the ends. Here `a` and `b` can be any value from extended real numbers.
+
+    The intended meaning of AccummulationBounds is to give an approximate
+    location of the accumulation points of a real function at a limit point.
+
+    Let `a` and `b` be reals such that `a \le b`.
+
+    `\left\langle a, b\right\rangle = \{x \in \mathbb{R} \mid a \le x \le b\}`
+
+    `\left\langle -\infty, b\right\rangle = \{x \in \mathbb{R} \mid x \le b\} \cup \{-\infty, \infty\}`
+
+    `\left\langle a, \infty \right\rangle = \{x \in \mathbb{R} \mid a \le x\} \cup \{-\infty, \infty\}`
+
+    `\left\langle -\infty, \infty \right\rangle = \mathbb{R} \cup \{-\infty, \infty\}`
+
+    ``oo`` and ``-oo`` are added to the second and third definition respectively,
+    since if either ``-oo`` or ``oo`` is an argument, then the other one should
+    be included (though not as an end point). This is forced, since we have,
+    for example, ``1/AccumBounds(0, 1) = AccumBounds(1, oo)``, and the limit at
+    `0` is not one-sided. As `x` tends to `0-`, then `1/x \rightarrow -\infty`, so `-\infty`
+    should be interpreted as belonging to ``AccumBounds(1, oo)`` though it need
+    not appear explicitly.
+
+    In many cases it suffices to know that the limit set is bounded.
+    However, in some other cases more exact information could be useful.
+    For example, all accumulation values of `\cos(x) + 1` are non-negative.
+    (``AccumBounds(-1, 1) + 1 = AccumBounds(0, 2)``)
+
+    A AccumulationBounds object is defined to be real AccumulationBounds,
+    if its end points are finite reals.
+
+    Let `X`, `Y` be real AccumulationBounds, then their sum, difference,
+    product are defined to be the following sets:
+
+    `X + Y = \{ x+y \mid x \in X \cap y \in Y\}`
+
+    `X - Y = \{ x-y \mid x \in X \cap y \in Y\}`
+
+    `X \times Y = \{ x \times y \mid x \in X \cap y \in Y\}`
+
+    When an AccumBounds is raised to a negative power, if 0 is contained
+    between the bounds then an infinite range is returned, otherwise if an
+    endpoint is 0 then a semi-infinite range with consistent sign will be returned.
+
+    AccumBounds in expressions behave a lot like Intervals but the
+    semantics are not necessarily the same. Division (or exponentiation
+    to a negative integer power) could be handled with *intervals* by
+    returning a union of the results obtained after splitting the
+    bounds between negatives and positives, but that is not done with
+    AccumBounds. In addition, bounds are assumed to be independent of
+    each other; if the same bound is used in more than one place in an
+    expression, the result may not be the supremum or infimum of the
+    expression (see below). Finally, when a boundary is ``1``,
+    exponentiation to the power of ``oo`` yields ``oo``, neither
+    ``1`` nor ``nan``.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, sin, exp, log, pi, E, S, oo
+    >>> from sympy.abc import x
+
+    >>> AccumBounds(0, 1) + AccumBounds(1, 2)
+    AccumBounds(1, 3)
+
+    >>> AccumBounds(0, 1) - AccumBounds(0, 2)
+    AccumBounds(-2, 1)
+
+    >>> AccumBounds(-2, 3)*AccumBounds(-1, 1)
+    AccumBounds(-3, 3)
+
+    >>> AccumBounds(1, 2)*AccumBounds(3, 5)
+    AccumBounds(3, 10)
+
+    The exponentiation of AccumulationBounds is defined
+    as follows:
+
+    If 0 does not belong to `X` or `n > 0` then
+
+    `X^n = \{ x^n \mid x \in X\}`
+
+    >>> AccumBounds(1, 4)**(S(1)/2)
+    AccumBounds(1, 2)
+
+    otherwise, an infinite or semi-infinite result is obtained:
+
+    >>> 1/AccumBounds(-1, 1)
+    AccumBounds(-oo, oo)
+    >>> 1/AccumBounds(0, 2)
+    AccumBounds(1/2, oo)
+    >>> 1/AccumBounds(-oo, 0)
+    AccumBounds(-oo, 0)
+
+    A boundary of 1 will always generate all nonnegatives:
+
+    >>> AccumBounds(1, 2)**oo
+    AccumBounds(0, oo)
+    >>> AccumBounds(0, 1)**oo
+    AccumBounds(0, oo)
+
+    If the exponent is itself an AccumulationBounds or is not an
+    integer then unevaluated results will be returned unless the base
+    values are positive:
+
+    >>> AccumBounds(2, 3)**AccumBounds(-1, 2)
+    AccumBounds(1/3, 9)
+    >>> AccumBounds(-2, 3)**AccumBounds(-1, 2)
+    AccumBounds(-2, 3)**AccumBounds(-1, 2)
+
+    >>> AccumBounds(-2, -1)**(S(1)/2)
+    sqrt(AccumBounds(-2, -1))
+
+    Note: `\left\langle a, b\right\rangle^2` is not same as `\left\langle a, b\right\rangle \times \left\langle a, b\right\rangle`
+
+    >>> AccumBounds(-1, 1)**2
+    AccumBounds(0, 1)
+
+    >>> AccumBounds(1, 3) < 4
+    True
+
+    >>> AccumBounds(1, 3) < -1
+    False
+
+    Some elementary functions can also take AccumulationBounds as input.
+    A function `f` evaluated for some real AccumulationBounds `\left\langle a, b \right\rangle`
+    is defined as `f(\left\langle a, b\right\rangle) = \{ f(x) \mid a \le x \le b \}`
+
+    >>> sin(AccumBounds(pi/6, pi/3))
+    AccumBounds(1/2, sqrt(3)/2)
+
+    >>> exp(AccumBounds(0, 1))
+    AccumBounds(1, E)
+
+    >>> log(AccumBounds(1, E))
+    AccumBounds(0, 1)
+
+    Some symbol in an expression can be substituted for a AccumulationBounds
+    object. But it does not necessarily evaluate the AccumulationBounds for
+    that expression.
+
+    The same expression can be evaluated to different values depending upon
+    the form it is used for substitution since each instance of an
+    AccumulationBounds is considered independent. For example:
+
+    >>> (x**2 + 2*x + 1).subs(x, AccumBounds(-1, 1))
+    AccumBounds(-1, 4)
+
+    >>> ((x + 1)**2).subs(x, AccumBounds(-1, 1))
+    AccumBounds(0, 4)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Interval_arithmetic
+
+    .. [2] https://fab.cba.mit.edu/classes/S62.12/docs/Hickey_interval.pdf
+
+    Notes
+    =====
+
+    Do not use ``AccumulationBounds`` for floating point interval arithmetic
+    calculations, use ``mpmath.iv`` instead.
+    """
+
+    is_extended_real = True
+    is_number = False
+
+    def __new__(cls, min, max) -> Expr: # type: ignore
+
+        min = _sympify(min)
+        max = _sympify(max)
+
+        # Only allow real intervals (use symbols with 'is_extended_real=True').
+        if not min.is_extended_real or not max.is_extended_real:
+            raise ValueError("Only real AccumulationBounds are supported")
+
+        if max == min:
+            return max
+
+        # Make sure that the created AccumBounds object will be valid.
+        if max.is_number and min.is_number:
+            bad = max.is_comparable and min.is_comparable and max < min
+        else:
+            bad = (max - min).is_extended_negative
+        if bad:
+            raise ValueError(
+                "Lower limit should be smaller than upper limit")
+
+        return Basic.__new__(cls, min, max)
+
+    # setting the operation priority
+    _op_priority = 11.0
+
+    def _eval_is_real(self):
+        if self.min.is_real and self.max.is_real:
+            return True
+
+    @property
+    def min(self):
+        """
+        Returns the minimum possible value attained by AccumulationBounds
+        object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).min
+        1
+
+        """
+        return self.args[0]
+
+    @property
+    def max(self):
+        """
+        Returns the maximum possible value attained by AccumulationBounds
+        object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).max
+        3
+
+        """
+        return self.args[1]
+
+    @property
+    def delta(self):
+        """
+        Returns the difference of maximum possible value attained by
+        AccumulationBounds object and minimum possible value attained
+        by AccumulationBounds object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).delta
+        2
+
+        """
+        return self.max - self.min
+
+    @property
+    def mid(self):
+        """
+        Returns the mean of maximum possible value attained by
+        AccumulationBounds object and minimum possible value
+        attained by AccumulationBounds object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).mid
+        2
+
+        """
+        return (self.min + self.max) / 2
+
+    @_sympifyit('other', NotImplemented)
+    def _eval_power(self, other):
+        return self.__pow__(other)
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                return AccumBounds(
+                    Add(self.min, other.min),
+                    Add(self.max, other.max))
+            if other is S.Infinity and self.min is S.NegativeInfinity or \
+                    other is S.NegativeInfinity and self.max is S.Infinity:
+                return AccumBounds(-oo, oo)
+            elif other.is_extended_real:
+                if self.min is S.NegativeInfinity and self.max is S.Infinity:
+                    return AccumBounds(-oo, oo)
+                elif self.min is S.NegativeInfinity:
+                    return AccumBounds(-oo, self.max + other)
+                elif self.max is S.Infinity:
+                    return AccumBounds(self.min + other, oo)
+                else:
+                    return AccumBounds(Add(self.min, other), Add(self.max, other))
+            return Add(self, other, evaluate=False)
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return AccumBounds(-self.max, -self.min)
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                return AccumBounds(
+                    Add(self.min, -other.max),
+                    Add(self.max, -other.min))
+            if other is S.NegativeInfinity and self.min is S.NegativeInfinity or \
+                    other is S.Infinity and self.max is S.Infinity:
+                return AccumBounds(-oo, oo)
+            elif other.is_extended_real:
+                if self.min is S.NegativeInfinity and self.max is S.Infinity:
+                    return AccumBounds(-oo, oo)
+                elif self.min is S.NegativeInfinity:
+                    return AccumBounds(-oo, self.max - other)
+                elif self.max is S.Infinity:
+                    return AccumBounds(self.min - other, oo)
+                else:
+                    return AccumBounds(
+                        Add(self.min, -other),
+                        Add(self.max, -other))
+            return Add(self, -other, evaluate=False)
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rsub__(self, other):
+        return self.__neg__() + other
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if self.args == (-oo, oo):
+            return self
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                if other.args == (-oo, oo):
+                    return other
+                v = set()
+                for a in self.args:
+                    vi = other*a
+                    v.update(vi.args or (vi,))
+                return AccumBounds(Min(*v), Max(*v))
+            if other is S.Infinity:
+                if self.min.is_zero:
+                    return AccumBounds(0, oo)
+                if self.max.is_zero:
+                    return AccumBounds(-oo, 0)
+            if other is S.NegativeInfinity:
+                if self.min.is_zero:
+                    return AccumBounds(-oo, 0)
+                if self.max.is_zero:
+                    return AccumBounds(0, oo)
+            if other.is_extended_real:
+                if other.is_zero:
+                    if self.max is S.Infinity:
+                        return AccumBounds(0, oo)
+                    if self.min is S.NegativeInfinity:
+                        return AccumBounds(-oo, 0)
+                    return S.Zero
+                if other.is_extended_positive:
+                    return AccumBounds(
+                        Mul(self.min, other),
+                        Mul(self.max, other))
+                elif other.is_extended_negative:
+                    return AccumBounds(
+                        Mul(self.max, other),
+                        Mul(self.min, other))
+            if isinstance(other, Order):
+                return other
+            return Mul(self, other, evaluate=False)
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                if other.min.is_positive or other.max.is_negative:
+                    return self * AccumBounds(1/other.max, 1/other.min)
+
+                if (self.min.is_extended_nonpositive and self.max.is_extended_nonnegative and
+                    other.min.is_extended_nonpositive and other.max.is_extended_nonnegative):
+                    if self.min.is_zero and other.min.is_zero:
+                        return AccumBounds(0, oo)
+                    if self.max.is_zero and other.min.is_zero:
+                        return AccumBounds(-oo, 0)
+                    return AccumBounds(-oo, oo)
+
+                if self.max.is_extended_negative:
+                    if other.min.is_extended_negative:
+                        if other.max.is_zero:
+                            return AccumBounds(self.max / other.min, oo)
+                        if other.max.is_extended_positive:
+                            # if we were dealing with intervals we would return
+                            # Union(Interval(-oo, self.max/other.max),
+                            #       Interval(self.max/other.min, oo))
+                            return AccumBounds(-oo, oo)
+
+                    if other.min.is_zero and other.max.is_extended_positive:
+                        return AccumBounds(-oo, self.max / other.max)
+
+                if self.min.is_extended_positive:
+                    if other.min.is_extended_negative:
+                        if other.max.is_zero:
+                            return AccumBounds(-oo, self.min / other.min)
+                        if other.max.is_extended_positive:
+                            # if we were dealing with intervals we would return
+                            # Union(Interval(-oo, self.min/other.min),
+                            #       Interval(self.min/other.max, oo))
+                            return AccumBounds(-oo, oo)
+
+                    if other.min.is_zero and other.max.is_extended_positive:
+                        return AccumBounds(self.min / other.max, oo)
+
+            elif other.is_extended_real:
+                if other in (S.Infinity, S.NegativeInfinity):
+                    if self == AccumBounds(-oo, oo):
+                        return AccumBounds(-oo, oo)
+                    if self.max is S.Infinity:
+                        return AccumBounds(Min(0, other), Max(0, other))
+                    if self.min is S.NegativeInfinity:
+                        return AccumBounds(Min(0, -other), Max(0, -other))
+                if other.is_extended_positive:
+                    return AccumBounds(self.min / other, self.max / other)
+                elif other.is_extended_negative:
+                    return AccumBounds(self.max / other, self.min / other)
+            if (1 / other) is S.ComplexInfinity:
+                return Mul(self, 1 / other, evaluate=False)
+            else:
+                return Mul(self, 1 / other)
+
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rtruediv__(self, other):
+        if isinstance(other, Expr):
+            if other.is_extended_real:
+                if other.is_zero:
+                    return S.Zero
+                if (self.min.is_extended_nonpositive and self.max.is_extended_nonnegative):
+                    if self.min.is_zero:
+                        if other.is_extended_positive:
+                            return AccumBounds(Mul(other, 1 / self.max), oo)
+                        if other.is_extended_negative:
+                            return AccumBounds(-oo, Mul(other, 1 / self.max))
+                    if self.max.is_zero:
+                        if other.is_extended_positive:
+                            return AccumBounds(-oo, Mul(other, 1 / self.min))
+                        if other.is_extended_negative:
+                            return AccumBounds(Mul(other, 1 / self.min), oo)
+                    return AccumBounds(-oo, oo)
+                else:
+                    return AccumBounds(Min(other / self.min, other / self.max),
+                                       Max(other / self.min, other / self.max))
+            return Mul(other, 1 / self, evaluate=False)
+        else:
+            return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __pow__(self, other):
+        if isinstance(other, Expr):
+            if other is S.Infinity:
+                if self.min.is_extended_nonnegative:
+                    if self.max < 1:
+                        return S.Zero
+                    if self.min > 1:
+                        return S.Infinity
+                    return AccumBounds(0, oo)
+                elif self.max.is_extended_negative:
+                    if self.min > -1:
+                        return S.Zero
+                    if self.max < -1:
+                        return zoo
+                    return S.NaN
+                else:
+                    if self.min > -1:
+                        if self.max < 1:
+                            return S.Zero
+                        return AccumBounds(0, oo)
+                    return AccumBounds(-oo, oo)
+
+            if other is S.NegativeInfinity:
+                return (1/self)**oo
+
+            # generically true
+            if (self.max - self.min).is_nonnegative:
+                # well defined
+                if self.min.is_nonnegative:
+                    # no 0 to worry about
+                    if other.is_nonnegative:
+                        # no infinity to worry about
+                        return self.func(self.min**other, self.max**other)
+
+            if other.is_zero:
+                return S.One  # x**0 = 1
+
+            if other.is_Integer or other.is_integer:
+                if self.min.is_extended_positive:
+                    return AccumBounds(
+                        Min(self.min**other, self.max**other),
+                        Max(self.min**other, self.max**other))
+                elif self.max.is_extended_negative:
+                    return AccumBounds(
+                        Min(self.max**other, self.min**other),
+                        Max(self.max**other, self.min**other))
+
+                if other % 2 == 0:
+                    if other.is_extended_negative:
+                        if self.min.is_zero:
+                            return AccumBounds(self.max**other, oo)
+                        if self.max.is_zero:
+                            return AccumBounds(self.min**other, oo)
+                        return (1/self)**(-other)
+                    return AccumBounds(
+                        S.Zero, Max(self.min**other, self.max**other))
+                elif other % 2 == 1:
+                    if other.is_extended_negative:
+                        if self.min.is_zero:
+                            return AccumBounds(self.max**other, oo)
+                        if self.max.is_zero:
+                            return AccumBounds(-oo, self.min**other)
+                        return (1/self)**(-other)
+                    return AccumBounds(self.min**other, self.max**other)
+
+            # non-integer exponent
+            # 0**neg or neg**frac yields complex
+            if (other.is_number or other.is_rational) and (
+                    self.min.is_extended_nonnegative or (
+                    other.is_extended_nonnegative and
+                    self.min.is_extended_nonnegative)):
+                num, den = other.as_numer_denom()
+                if num is S.One:
+                    return AccumBounds(*[i**(1/den) for i in self.args])
+
+                elif den is not S.One:  # e.g. if other is not Float
+                    return (self**num)**(1/den)  # ok for non-negative base
+
+            if isinstance(other, AccumBounds):
+                if (self.min.is_extended_positive or
+                        self.min.is_extended_nonnegative and
+                        other.min.is_extended_nonnegative):
+                    p = [self**i for i in other.args]
+                    if not any(i.is_Pow for i in p):
+                        a = [j for i in p for j in i.args or (i,)]
+                        try:
+                            return self.func(min(a), max(a))
+                        except TypeError:  # can't sort
+                            pass
+
+            return Pow(self, other, evaluate=False)
+
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rpow__(self, other):
+        if other.is_real and other.is_extended_nonnegative and (
+                self.max - self.min).is_extended_positive:
+            if other is S.One:
+                return S.One
+            if other.is_extended_positive:
+                a, b = [other**i for i in self.args]
+                if min(a, b) != a:
+                    a, b = b, a
+                return self.func(a, b)
+            if other.is_zero:
+                if self.min.is_zero:
+                    return self.func(0, 1)
+                if self.min.is_extended_positive:
+                    return S.Zero
+
+        return Pow(other, self, evaluate=False)
+
+    def __abs__(self):
+        if self.max.is_extended_negative:
+            return self.__neg__()
+        elif self.min.is_extended_negative:
+            return AccumBounds(S.Zero, Max(abs(self.min), self.max))
+        else:
+            return self
+
+
+    def __contains__(self, other):
+        """
+        Returns ``True`` if other is contained in self, where other
+        belongs to extended real numbers, ``False`` if not contained,
+        otherwise TypeError is raised.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds, oo
+        >>> 1 in AccumBounds(-1, 3)
+        True
+
+        -oo and oo go together as limits (in AccumulationBounds).
+
+        >>> -oo in AccumBounds(1, oo)
+        True
+
+        >>> oo in AccumBounds(-oo, 0)
+        True
+
+        """
+        other = _sympify(other)
+
+        if other in (S.Infinity, S.NegativeInfinity):
+            if self.min is S.NegativeInfinity or self.max is S.Infinity:
+                return True
+            return False
+
+        rv = And(self.min <= other, self.max >= other)
+        if rv not in (True, False):
+            raise TypeError("input failed to evaluate")
+        return rv
+
+    def intersection(self, other):
+        """
+        Returns the intersection of 'self' and 'other'.
+        Here other can be an instance of :py:class:`~.FiniteSet` or AccumulationBounds.
+
+        Parameters
+        ==========
+
+        other : AccumulationBounds
+            Another AccumulationBounds object with which the intersection
+            has to be computed.
+
+        Returns
+        =======
+
+        AccumulationBounds
+            Intersection of ``self`` and ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds, FiniteSet
+        >>> AccumBounds(1, 3).intersection(AccumBounds(2, 4))
+        AccumBounds(2, 3)
+
+        >>> AccumBounds(1, 3).intersection(AccumBounds(4, 6))
+        EmptySet
+
+        >>> AccumBounds(1, 4).intersection(FiniteSet(1, 2, 5))
+        {1, 2}
+
+        """
+        if not isinstance(other, (AccumBounds, FiniteSet)):
+            raise TypeError(
+                "Input must be AccumulationBounds or FiniteSet object")
+
+        if isinstance(other, FiniteSet):
+            fin_set = S.EmptySet
+            for i in other:
+                if i in self:
+                    fin_set = fin_set + FiniteSet(i)
+            return fin_set
+
+        if self.max < other.min or self.min > other.max:
+            return S.EmptySet
+
+        if self.min <= other.min:
+            if self.max <= other.max:
+                return AccumBounds(other.min, self.max)
+            if self.max > other.max:
+                return other
+
+        if other.min <= self.min:
+            if other.max < self.max:
+                return AccumBounds(self.min, other.max)
+            if other.max > self.max:
+                return self
+
+    def union(self, other):
+        # TODO : Devise a better method for Union of AccumBounds
+        # this method is not actually correct and
+        # can be made better
+        if not isinstance(other, AccumBounds):
+            raise TypeError(
+                "Input must be AccumulationBounds or FiniteSet object")
+
+        if self.min <= other.min and self.max >= other.min:
+            return AccumBounds(self.min, Max(self.max, other.max))
+
+        if other.min <= self.min and other.max >= self.min:
+            return AccumBounds(other.min, Max(self.max, other.max))
+
+
+@dispatch(AccumulationBounds, AccumulationBounds) # type: ignore # noqa:F811
+def _eval_is_le(lhs, rhs): # noqa:F811
+    if is_le(lhs.max, rhs.min):
+        return True
+    if is_gt(lhs.min, rhs.max):
+        return False
+
+
+@dispatch(AccumulationBounds, Basic) # type: ignore # noqa:F811
+def _eval_is_le(lhs, rhs): # noqa: F811
+
+    """
+    Returns ``True `` if range of values attained by ``lhs`` AccumulationBounds
+    object is greater than the range of values attained by ``rhs``,
+    where ``rhs`` may be any value of type AccumulationBounds object or
+    extended real number value, ``False`` if ``rhs`` satisfies
+    the same property, else an unevaluated :py:class:`~.Relational`.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, oo
+    >>> AccumBounds(1, 3) > AccumBounds(4, oo)
+    False
+    >>> AccumBounds(1, 4) > AccumBounds(3, 4)
+    AccumBounds(1, 4) > AccumBounds(3, 4)
+    >>> AccumBounds(1, oo) > -1
+    True
+
+    """
+    if not rhs.is_extended_real:
+            raise TypeError(
+                "Invalid comparison of %s %s" %
+                (type(rhs), rhs))
+    elif rhs.is_comparable:
+        if is_le(lhs.max, rhs):
+            return True
+        if is_gt(lhs.min, rhs):
+            return False
+
+
+@dispatch(AccumulationBounds, AccumulationBounds)
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if is_ge(lhs.min, rhs.max):
+        return True
+    if is_lt(lhs.max, rhs.min):
+        return False
+
+
+@dispatch(AccumulationBounds, Expr)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa: F811
+    """
+    Returns ``True`` if range of values attained by ``lhs`` AccumulationBounds
+    object is less that the range of values attained by ``rhs``, where
+    other may be any value of type AccumulationBounds object or extended
+    real number value, ``False`` if ``rhs`` satisfies the same
+    property, else an unevaluated :py:class:`~.Relational`.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, oo
+    >>> AccumBounds(1, 3) >= AccumBounds(4, oo)
+    False
+    >>> AccumBounds(1, 4) >= AccumBounds(3, 4)
+    AccumBounds(1, 4) >= AccumBounds(3, 4)
+    >>> AccumBounds(1, oo) >= 1
+    True
+    """
+
+    if not rhs.is_extended_real:
+        raise TypeError(
+            "Invalid comparison of %s %s" %
+            (type(rhs), rhs))
+    elif rhs.is_comparable:
+        if is_ge(lhs.min, rhs):
+            return True
+        if is_lt(lhs.max, rhs):
+            return False
+
+
+@dispatch(Expr, AccumulationBounds)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if not lhs.is_extended_real:
+        raise TypeError(
+            "Invalid comparison of %s %s" %
+            (type(lhs), lhs))
+    elif lhs.is_comparable:
+        if is_le(rhs.max, lhs):
+            return True
+        if is_gt(rhs.min, lhs):
+            return False
+
+
+@dispatch(AccumulationBounds, AccumulationBounds)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if is_ge(lhs.min, rhs.max):
+        return True
+    if is_lt(lhs.max, rhs.min):
+        return False
+
+# setting an alias for AccumulationBounds
+AccumBounds = AccumulationBounds

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/euler.py

@@ -0,0 +1,108 @@
+"""
+This module implements a method to find
+Euler-Lagrange Equations for given Lagrangian.
+"""
+from itertools import combinations_with_replacement
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.utilities.iterables import iterable
+
+
+def euler_equations(L, funcs=(), vars=()):
+    r"""
+    Find the Euler-Lagrange equations [1]_ for a given Lagrangian.
+
+    Parameters
+    ==========
+
+    L : Expr
+        The Lagrangian that should be a function of the functions listed
+        in the second argument and their derivatives.
+
+        For example, in the case of two functions $f(x,y)$, $g(x,y)$ and
+        two independent variables $x$, $y$ the Lagrangian has the form:
+
+            .. math:: L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},
+                      \frac{\partial f(x,y)}{\partial y},
+                      \frac{\partial g(x,y)}{\partial x},
+                      \frac{\partial g(x,y)}{\partial y},x,y\right)
+
+        In many cases it is not necessary to provide anything, except the
+        Lagrangian, it will be auto-detected (and an error raised if this
+        cannot be done).
+
+    funcs : Function or an iterable of Functions
+        The functions that the Lagrangian depends on. The Euler equations
+        are differential equations for each of these functions.
+
+    vars : Symbol or an iterable of Symbols
+        The Symbols that are the independent variables of the functions.
+
+    Returns
+    =======
+
+    eqns : list of Eq
+        The list of differential equations, one for each function.
+
+    Examples
+    ========
+
+    >>> from sympy import euler_equations, Symbol, Function
+    >>> x = Function('x')
+    >>> t = Symbol('t')
+    >>> L = (x(t).diff(t))**2/2 - x(t)**2/2
+    >>> euler_equations(L, x(t), t)
+    [Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
+    >>> u = Function('u')
+    >>> x = Symbol('x')
+    >>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
+    >>> euler_equations(L, u(t, x), [t, x])
+    [Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation
+
+    """
+
+    funcs = tuple(funcs) if iterable(funcs) else (funcs,)
+
+    if not funcs:
+        funcs = tuple(L.atoms(Function))
+    else:
+        for f in funcs:
+            if not isinstance(f, Function):
+                raise TypeError('Function expected, got: %s' % f)
+
+    vars = tuple(vars) if iterable(vars) else (vars,)
+
+    if not vars:
+        vars = funcs[0].args
+    else:
+        vars = tuple(sympify(var) for var in vars)
+
+    if not all(isinstance(v, Symbol) for v in vars):
+        raise TypeError('Variables are not symbols, got %s' % vars)
+
+    for f in funcs:
+        if not vars == f.args:
+            raise ValueError("Variables %s do not match args: %s" % (vars, f))
+
+    order = max([len(d.variables) for d in L.atoms(Derivative)
+                        if d.expr in funcs] + [0])
+
+    eqns = []
+    for f in funcs:
+        eq = diff(L, f)
+        for i in range(1, order + 1):
+            for p in combinations_with_replacement(vars, i):
+                eq = eq + S.NegativeOne**i*diff(L, diff(f, *p), *p)
+        new_eq = Eq(eq, 0)
+        if isinstance(new_eq, Eq):
+            eqns.append(new_eq)
+
+    return eqns

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/finite_diff.py

@@ -0,0 +1,476 @@
+"""
+Finite difference weights
+=========================
+
+This module implements an algorithm for efficient generation of finite
+difference weights for ordinary differentials of functions for
+derivatives from 0 (interpolation) up to arbitrary order.
+
+The core algorithm is provided in the finite difference weight generating
+function (``finite_diff_weights``), and two convenience functions are provided
+for:
+
+- estimating a derivative (or interpolate) directly from a series of points
+    is also provided (``apply_finite_diff``).
+- differentiating by using finite difference approximations
+    (``differentiate_finite``).
+
+"""
+
+from sympy.core.function import Derivative
+from sympy.core.singleton import S
+from sympy.core.function import Subs
+from sympy.core.traversal import preorder_traversal
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import iterable
+
+
+
+def finite_diff_weights(order, x_list, x0=S.One):
+    """
+    Calculates the finite difference weights for an arbitrarily spaced
+    one-dimensional grid (``x_list``) for derivatives at ``x0`` of order
+    0, 1, ..., up to ``order`` using a recursive formula. Order of accuracy
+    is at least ``len(x_list) - order``, if ``x_list`` is defined correctly.
+
+    Parameters
+    ==========
+
+    order: int
+        Up to what derivative order weights should be calculated.
+        0 corresponds to interpolation.
+    x_list: sequence
+        Sequence of (unique) values for the independent variable.
+        It is useful (but not necessary) to order ``x_list`` from
+        nearest to furthest from ``x0``; see examples below.
+    x0: Number or Symbol
+        Root or value of the independent variable for which the finite
+        difference weights should be generated. Default is ``S.One``.
+
+    Returns
+    =======
+
+    list
+        A list of sublists, each corresponding to coefficients for
+        increasing derivative order, and each containing lists of
+        coefficients for increasing subsets of x_list.
+
+    Examples
+    ========
+
+    >>> from sympy import finite_diff_weights, S
+    >>> res = finite_diff_weights(1, [-S(1)/2, S(1)/2, S(3)/2, S(5)/2], 0)
+    >>> res
+    [[[1, 0, 0, 0],
+      [1/2, 1/2, 0, 0],
+      [3/8, 3/4, -1/8, 0],
+      [5/16, 15/16, -5/16, 1/16]],
+     [[0, 0, 0, 0],
+      [-1, 1, 0, 0],
+      [-1, 1, 0, 0],
+      [-23/24, 7/8, 1/8, -1/24]]]
+    >>> res[0][-1]  # FD weights for 0th derivative, using full x_list
+    [5/16, 15/16, -5/16, 1/16]
+    >>> res[1][-1]  # FD weights for 1st derivative
+    [-23/24, 7/8, 1/8, -1/24]
+    >>> res[1][-2]  # FD weights for 1st derivative, using x_list[:-1]
+    [-1, 1, 0, 0]
+    >>> res[1][-1][0]  # FD weight for 1st deriv. for x_list[0]
+    -23/24
+    >>> res[1][-1][1]  # FD weight for 1st deriv. for x_list[1], etc.
+    7/8
+
+    Each sublist contains the most accurate formula at the end.
+    Note, that in the above example ``res[1][1]`` is the same as ``res[1][2]``.
+    Since res[1][2] has an order of accuracy of
+    ``len(x_list[:3]) - order = 3 - 1 = 2``, the same is true for ``res[1][1]``!
+
+    >>> res = finite_diff_weights(1, [S(0), S(1), -S(1), S(2), -S(2)], 0)[1]
+    >>> res
+    [[0, 0, 0, 0, 0],
+     [-1, 1, 0, 0, 0],
+     [0, 1/2, -1/2, 0, 0],
+     [-1/2, 1, -1/3, -1/6, 0],
+     [0, 2/3, -2/3, -1/12, 1/12]]
+    >>> res[0]  # no approximation possible, using x_list[0] only
+    [0, 0, 0, 0, 0]
+    >>> res[1]  # classic forward step approximation
+    [-1, 1, 0, 0, 0]
+    >>> res[2]  # classic centered approximation
+    [0, 1/2, -1/2, 0, 0]
+    >>> res[3:]  # higher order approximations
+    [[-1/2, 1, -1/3, -1/6, 0], [0, 2/3, -2/3, -1/12, 1/12]]
+
+    Let us compare this to a differently defined ``x_list``. Pay attention to
+    ``foo[i][k]`` corresponding to the gridpoint defined by ``x_list[k]``.
+
+    >>> foo = finite_diff_weights(1, [-S(2), -S(1), S(0), S(1), S(2)], 0)[1]
+    >>> foo
+    [[0, 0, 0, 0, 0],
+     [-1, 1, 0, 0, 0],
+     [1/2, -2, 3/2, 0, 0],
+     [1/6, -1, 1/2, 1/3, 0],
+     [1/12, -2/3, 0, 2/3, -1/12]]
+    >>> foo[1]  # not the same and of lower accuracy as res[1]!
+    [-1, 1, 0, 0, 0]
+    >>> foo[2]  # classic double backward step approximation
+    [1/2, -2, 3/2, 0, 0]
+    >>> foo[4]  # the same as res[4]
+    [1/12, -2/3, 0, 2/3, -1/12]
+
+    Note that, unless you plan on using approximations based on subsets of
+    ``x_list``, the order of gridpoints does not matter.
+
+    The capability to generate weights at arbitrary points can be
+    used e.g. to minimize Runge's phenomenon by using Chebyshev nodes:
+
+    >>> from sympy import cos, symbols, pi, simplify
+    >>> N, (h, x) = 4, symbols('h x')
+    >>> x_list = [x+h*cos(i*pi/(N)) for i in range(N,-1,-1)] # chebyshev nodes
+    >>> print(x_list)
+    [-h + x, -sqrt(2)*h/2 + x, x, sqrt(2)*h/2 + x, h + x]
+    >>> mycoeffs = finite_diff_weights(1, x_list, 0)[1][4]
+    >>> [simplify(c) for c in  mycoeffs] #doctest: +NORMALIZE_WHITESPACE
+    [(h**3/2 + h**2*x - 3*h*x**2 - 4*x**3)/h**4,
+    (-sqrt(2)*h**3 - 4*h**2*x + 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
+    (6*h**2*x - 8*x**3)/h**4,
+    (sqrt(2)*h**3 - 4*h**2*x - 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
+    (-h**3/2 + h**2*x + 3*h*x**2 - 4*x**3)/h**4]
+
+    Notes
+    =====
+
+    If weights for a finite difference approximation of 3rd order
+    derivative is wanted, weights for 0th, 1st and 2nd order are
+    calculated "for free", so are formulae using subsets of ``x_list``.
+    This is something one can take advantage of to save computational cost.
+    Be aware that one should define ``x_list`` from nearest to furthest from
+    ``x0``. If not, subsets of ``x_list`` will yield poorer approximations,
+    which might not grand an order of accuracy of ``len(x_list) - order``.
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.apply_finite_diff
+
+    References
+    ==========
+
+    .. [1] Generation of Finite Difference Formulas on Arbitrarily Spaced
+            Grids, Bengt Fornberg; Mathematics of computation; 51; 184;
+            (1988); 699-706; doi:10.1090/S0025-5718-1988-0935077-0
+
+    """
+    # The notation below closely corresponds to the one used in the paper.
+    order = S(order)
+    if not order.is_number:
+        raise ValueError("Cannot handle symbolic order.")
+    if order < 0:
+        raise ValueError("Negative derivative order illegal.")
+    if int(order) != order:
+        raise ValueError("Non-integer order illegal")
+    M = order
+    N = len(x_list) - 1
+    delta = [[[0 for nu in range(N+1)] for n in range(N+1)] for
+             m in range(M+1)]
+    delta[0][0][0] = S.One
+    c1 = S.One
+    for n in range(1, N+1):
+        c2 = S.One
+        for nu in range(n):
+            c3 = x_list[n] - x_list[nu]
+            c2 = c2 * c3
+            if n <= M:
+                delta[n][n-1][nu] = 0
+            for m in range(min(n, M)+1):
+                delta[m][n][nu] = (x_list[n]-x0)*delta[m][n-1][nu] -\
+                    m*delta[m-1][n-1][nu]
+                delta[m][n][nu] /= c3
+        for m in range(min(n, M)+1):
+            delta[m][n][n] = c1/c2*(m*delta[m-1][n-1][n-1] -
+                                    (x_list[n-1]-x0)*delta[m][n-1][n-1])
+        c1 = c2
+    return delta
+
+
+def apply_finite_diff(order, x_list, y_list, x0=S.Zero):
+    """
+    Calculates the finite difference approximation of
+    the derivative of requested order at ``x0`` from points
+    provided in ``x_list`` and ``y_list``.
+
+    Parameters
+    ==========
+
+    order: int
+        order of derivative to approximate. 0 corresponds to interpolation.
+    x_list: sequence
+        Sequence of (unique) values for the independent variable.
+    y_list: sequence
+        The function value at corresponding values for the independent
+        variable in x_list.
+    x0: Number or Symbol
+        At what value of the independent variable the derivative should be
+        evaluated. Defaults to 0.
+
+    Returns
+    =======
+
+    sympy.core.add.Add or sympy.core.numbers.Number
+        The finite difference expression approximating the requested
+        derivative order at ``x0``.
+
+    Examples
+    ========
+
+    >>> from sympy import apply_finite_diff
+    >>> cube = lambda arg: (1.0*arg)**3
+    >>> xlist = range(-3,3+1)
+    >>> apply_finite_diff(2, xlist, map(cube, xlist), 2) - 12 # doctest: +SKIP
+    -3.55271367880050e-15
+
+    we see that the example above only contain rounding errors.
+    apply_finite_diff can also be used on more abstract objects:
+
+    >>> from sympy import IndexedBase, Idx
+    >>> x, y = map(IndexedBase, 'xy')
+    >>> i = Idx('i')
+    >>> x_list, y_list = zip(*[(x[i+j], y[i+j]) for j in range(-1,2)])
+    >>> apply_finite_diff(1, x_list, y_list, x[i])
+    ((x[i + 1] - x[i])/(-x[i - 1] + x[i]) - 1)*y[i]/(x[i + 1] - x[i]) -
+    (x[i + 1] - x[i])*y[i - 1]/((x[i + 1] - x[i - 1])*(-x[i - 1] + x[i])) +
+    (-x[i - 1] + x[i])*y[i + 1]/((x[i + 1] - x[i - 1])*(x[i + 1] - x[i]))
+
+    Notes
+    =====
+
+    Order = 0 corresponds to interpolation.
+    Only supply so many points you think makes sense
+    to around x0 when extracting the derivative (the function
+    need to be well behaved within that region). Also beware
+    of Runge's phenomenon.
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.finite_diff_weights
+
+    References
+    ==========
+
+    Fortran 90 implementation with Python interface for numerics: finitediff_
+
+    .. _finitediff: https://github.com/bjodah/finitediff
+
+    """
+
+    # In the original paper the following holds for the notation:
+    # M = order
+    # N = len(x_list) - 1
+
+    N = len(x_list) - 1
+    if len(x_list) != len(y_list):
+        raise ValueError("x_list and y_list not equal in length.")
+
+    delta = finite_diff_weights(order, x_list, x0)
+
+    derivative = 0
+    for nu in range(len(x_list)):
+        derivative += delta[order][N][nu]*y_list[nu]
+    return derivative
+
+
+def _as_finite_diff(derivative, points=1, x0=None, wrt=None):
+    """
+    Returns an approximation of a derivative of a function in
+    the form of a finite difference formula. The expression is a
+    weighted sum of the function at a number of discrete values of
+    (one of) the independent variable(s).
+
+    Parameters
+    ==========
+
+    derivative: a Derivative instance
+
+    points: sequence or coefficient, optional
+        If sequence: discrete values (length >= order+1) of the
+        independent variable used for generating the finite
+        difference weights.
+        If it is a coefficient, it will be used as the step-size
+        for generating an equidistant sequence of length order+1
+        centered around ``x0``. default: 1 (step-size 1)
+
+    x0: number or Symbol, optional
+        the value of the independent variable (``wrt``) at which the
+        derivative is to be approximated. Default: same as ``wrt``.
+
+    wrt: Symbol, optional
+        "with respect to" the variable for which the (partial)
+        derivative is to be approximated for. If not provided it
+        is required that the Derivative is ordinary. Default: ``None``.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Function, exp, sqrt, Symbol
+    >>> from sympy.calculus.finite_diff import _as_finite_diff
+    >>> x, h = symbols('x h')
+    >>> f = Function('f')
+    >>> _as_finite_diff(f(x).diff(x))
+    -f(x - 1/2) + f(x + 1/2)
+
+    The default step size and number of points are 1 and ``order + 1``
+    respectively. We can change the step size by passing a symbol
+    as a parameter:
+
+    >>> _as_finite_diff(f(x).diff(x), h)
+    -f(-h/2 + x)/h + f(h/2 + x)/h
+
+    We can also specify the discretized values to be used in a sequence:
+
+    >>> _as_finite_diff(f(x).diff(x), [x, x+h, x+2*h])
+    -3*f(x)/(2*h) + 2*f(h + x)/h - f(2*h + x)/(2*h)
+
+    The algorithm is not restricted to use equidistant spacing, nor
+    do we need to make the approximation around ``x0``, but we can get
+    an expression estimating the derivative at an offset:
+
+    >>> e, sq2 = exp(1), sqrt(2)
+    >>> xl = [x-h, x+h, x+e*h]
+    >>> _as_finite_diff(f(x).diff(x, 1), xl, x+h*sq2)
+    2*h*((h + sqrt(2)*h)/(2*h) - (-sqrt(2)*h + h)/(2*h))*f(E*h + x)/((-h + E*h)*(h + E*h)) +
+    (-(-sqrt(2)*h + h)/(2*h) - (-sqrt(2)*h + E*h)/(2*h))*f(-h + x)/(h + E*h) +
+    (-(h + sqrt(2)*h)/(2*h) + (-sqrt(2)*h + E*h)/(2*h))*f(h + x)/(-h + E*h)
+
+    Partial derivatives are also supported:
+
+    >>> y = Symbol('y')
+    >>> d2fdxdy=f(x,y).diff(x,y)
+    >>> _as_finite_diff(d2fdxdy, wrt=x)
+    -Derivative(f(x - 1/2, y), y) + Derivative(f(x + 1/2, y), y)
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.apply_finite_diff
+    sympy.calculus.finite_diff.finite_diff_weights
+
+    """
+    if derivative.is_Derivative:
+        pass
+    elif derivative.is_Atom:
+        return derivative
+    else:
+        return derivative.fromiter(
+            [_as_finite_diff(ar, points, x0, wrt) for ar
+             in derivative.args], **derivative.assumptions0)
+
+    if wrt is None:
+        old = None
+        for v in derivative.variables:
+            if old is v:
+                continue
+            derivative = _as_finite_diff(derivative, points, x0, v)
+            old = v
+        return derivative
+
+    order = derivative.variables.count(wrt)
+
+    if x0 is None:
+        x0 = wrt
+
+    if not iterable(points):
+        if getattr(points, 'is_Function', False) and wrt in points.args:
+            points = points.subs(wrt, x0)
+        # points is simply the step-size, let's make it a
+        # equidistant sequence centered around x0
+        if order % 2 == 0:
+            # even order => odd number of points, grid point included
+            points = [x0 + points*i for i
+                      in range(-order//2, order//2 + 1)]
+        else:
+            # odd order => even number of points, half-way wrt grid point
+            points = [x0 + points*S(i)/2 for i
+                      in range(-order, order + 1, 2)]
+    others = [wrt, 0]
+    for v in set(derivative.variables):
+        if v == wrt:
+            continue
+        others += [v, derivative.variables.count(v)]
+    if len(points) < order+1:
+        raise ValueError("Too few points for order %d" % order)
+    return apply_finite_diff(order, points, [
+        Derivative(derivative.expr.subs({wrt: x}), *others) for
+        x in points], x0)
+
+
+def differentiate_finite(expr, *symbols,
+                         points=1, x0=None, wrt=None, evaluate=False):
+    r""" Differentiate expr and replace Derivatives with finite differences.
+
+    Parameters
+    ==========
+
+    expr : expression
+    \*symbols : differentiate with respect to symbols
+    points: sequence, coefficient or undefined function, optional
+        see ``Derivative.as_finite_difference``
+    x0: number or Symbol, optional
+        see ``Derivative.as_finite_difference``
+    wrt: Symbol, optional
+        see ``Derivative.as_finite_difference``
+
+    Examples
+    ========
+
+    >>> from sympy import sin, Function, differentiate_finite
+    >>> from sympy.abc import x, y, h
+    >>> f, g = Function('f'), Function('g')
+    >>> differentiate_finite(f(x)*g(x), x, points=[x-h, x+h])
+    -f(-h + x)*g(-h + x)/(2*h) + f(h + x)*g(h + x)/(2*h)
+
+    ``differentiate_finite`` works on any expression, including the expressions
+    with embedded derivatives:
+
+    >>> differentiate_finite(f(x) + sin(x), x, 2)
+    -2*f(x) + f(x - 1) + f(x + 1) - 2*sin(x) + sin(x - 1) + sin(x + 1)
+    >>> differentiate_finite(f(x, y), x, y)
+    f(x - 1/2, y - 1/2) - f(x - 1/2, y + 1/2) - f(x + 1/2, y - 1/2) + f(x + 1/2, y + 1/2)
+    >>> differentiate_finite(f(x)*g(x).diff(x), x)
+    (-g(x) + g(x + 1))*f(x + 1/2) - (g(x) - g(x - 1))*f(x - 1/2)
+
+    To make finite difference with non-constant discretization step use
+    undefined functions:
+
+    >>> dx = Function('dx')
+    >>> differentiate_finite(f(x)*g(x).diff(x), points=dx(x))
+    -(-g(x - dx(x)/2 - dx(x - dx(x)/2)/2)/dx(x - dx(x)/2) +
+    g(x - dx(x)/2 + dx(x - dx(x)/2)/2)/dx(x - dx(x)/2))*f(x - dx(x)/2)/dx(x) +
+    (-g(x + dx(x)/2 - dx(x + dx(x)/2)/2)/dx(x + dx(x)/2) +
+    g(x + dx(x)/2 + dx(x + dx(x)/2)/2)/dx(x + dx(x)/2))*f(x + dx(x)/2)/dx(x)
+
+    """
+    if any(term.is_Derivative for term in list(preorder_traversal(expr))):
+        evaluate = False
+
+    Dexpr = expr.diff(*symbols, evaluate=evaluate)
+    if evaluate:
+        sympy_deprecation_warning("""
+        The evaluate flag to differentiate_finite() is deprecated.
+
+        evaluate=True expands the intermediate derivatives before computing
+        differences, but this usually not what you want, as it does not
+        satisfy the product rule.
+        """,
+            deprecated_since_version="1.5",
+             active_deprecations_target="deprecated-differentiate_finite-evaluate",
+        )
+        return Dexpr.replace(
+            lambda arg: arg.is_Derivative,
+            lambda arg: arg.as_finite_difference(points=points, x0=x0, wrt=wrt))
+    else:
+        DFexpr = Dexpr.as_finite_difference(points=points, x0=x0, wrt=wrt)
+        return DFexpr.replace(
+            lambda arg: isinstance(arg, Subs),
+            lambda arg: arg.expr.as_finite_difference(
+                    points=points, x0=arg.point[0], wrt=arg.variables[0]))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/singularities.py

@@ -0,0 +1,406 @@
+"""
+Singularities
+=============
+
+This module implements algorithms for finding singularities for a function
+and identifying types of functions.
+
+The differential calculus methods in this module include methods to identify
+the following function types in the given ``Interval``:
+- Increasing
+- Strictly Increasing
+- Decreasing
+- Strictly Decreasing
+- Monotonic
+
+"""
+
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import sec, csc, cot, tan, cos
+from sympy.functions.elementary.hyperbolic import (
+    sech, csch, coth, tanh, cosh, asech, acsch, atanh, acoth)
+from sympy.utilities.misc import filldedent
+
+
+def singularities(expression, symbol, domain=None):
+    """
+    Find singularities of a given function.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function in which singularities need to be found.
+    symbol : Symbol
+        The symbol over the values of which the singularity in
+        expression in being searched for.
+
+    Returns
+    =======
+
+    Set
+        A set of values for ``symbol`` for which ``expression`` has a
+        singularity. An ``EmptySet`` is returned if ``expression`` has no
+        singularities for any given value of ``Symbol``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Methods for determining the singularities of this function have
+        not been developed.
+
+    Notes
+    =====
+
+    This function does not find non-isolated singularities
+    nor does it find branch points of the expression.
+
+    Currently supported functions are:
+        - univariate continuous (real or complex) functions
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathematical_singularity
+
+    Examples
+    ========
+
+    >>> from sympy import singularities, Symbol, log
+    >>> x = Symbol('x', real=True)
+    >>> y = Symbol('y', real=False)
+    >>> singularities(x**2 + x + 1, x)
+    EmptySet
+    >>> singularities(1/(x + 1), x)
+    {-1}
+    >>> singularities(1/(y**2 + 1), y)
+    {-I, I}
+    >>> singularities(1/(y**3 + 1), y)
+    {-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2}
+    >>> singularities(log(x), x)
+    {0}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is None:
+        domain = S.Reals if symbol.is_real else S.Complexes
+    try:
+        sings = S.EmptySet
+        e = expression.rewrite([sec, csc, cot, tan], cos)
+        e = e.rewrite([sech, csch, coth, tanh], cosh)
+        for i in e.atoms(Pow):
+            if i.exp.is_infinite:
+                raise NotImplementedError
+            if i.exp.is_negative:
+                # XXX: exponent of varying sign not handled
+                sings += solveset(i.base, symbol, domain)
+        for i in expression.atoms(log, asech, acsch):
+            sings += solveset(i.args[0], symbol, domain)
+        for i in expression.atoms(atanh, acoth):
+            sings += solveset(i.args[0] - 1, symbol, domain)
+            sings += solveset(i.args[0] + 1, symbol, domain)
+        return sings
+    except NotImplementedError:
+        raise NotImplementedError(filldedent('''
+            Methods for determining the singularities
+            of this function have not been developed.'''))
+
+
+###########################################################################
+#                      DIFFERENTIAL CALCULUS METHODS                      #
+###########################################################################
+
+
+def monotonicity_helper(expression, predicate, interval=S.Reals, symbol=None):
+    """
+    Helper function for functions checking function monotonicity.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked
+    predicate : function
+        The property being tested for. The function takes in an integer
+        and returns a boolean. The integer input is the derivative and
+        the boolean result should be true if the property is being held,
+        and false otherwise.
+    interval : Set, optional
+        The range of values in which we are testing, defaults to all reals.
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    It returns a boolean indicating whether the interval in which
+    the function's derivative satisfies given predicate is a superset
+    of the given interval.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``predicate`` is true for all the derivatives when ``symbol``
+        is varied in ``range``, False otherwise.
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+    free = expression.free_symbols
+
+    if symbol is None:
+        if len(free) > 1:
+            raise NotImplementedError(
+                'The function has not yet been implemented'
+                ' for all multivariate expressions.'
+            )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    derivative = expression.diff(variable)
+    predicate_interval = solveset(predicate(derivative), variable, S.Reals)
+    return interval.is_subset(predicate_interval)
+
+
+def is_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is increasing (either strictly increasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_increasing(-x**2, Interval(-oo, 0))
+    True
+    >>> is_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    False
+    >>> is_increasing(x**2 + y, Interval(1, 2), x)
+    True
+
+    """
+    return monotonicity_helper(expression, lambda x: x >= 0, interval, symbol)
+
+
+def is_strictly_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly increasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import Interval, oo
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    False
+    >>> is_strictly_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_strictly_increasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x > 0, interval, symbol)
+
+
+def is_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is decreasing (either strictly decreasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x <= 0, interval, symbol)
+
+
+def is_strictly_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly decreasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x < 0, interval, symbol)
+
+
+def is_monotonic(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is monotonic in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is monotonic in the given ``interval``,
+        False otherwise.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Monotonicity check has not been implemented for the queried function.
+
+    Examples
+    ========
+
+    >>> from sympy import is_monotonic
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_monotonic(-x**2, S.Reals)
+    False
+    >>> is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    True
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+
+    free = expression.free_symbols
+    if symbol is None and len(free) > 1:
+        raise NotImplementedError(
+            'is_monotonic has not yet been implemented'
+            ' for all multivariate expressions.'
+        )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    turning_points = solveset(expression.diff(variable), variable, interval)
+    return interval.intersection(turning_points) is S.EmptySet

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/tests/test_accumulationbounds.py

@@ -0,0 +1,336 @@
+from sympy.core.numbers import (E, Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core import Add, Mul, Pow
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises, XFAIL
+from sympy.abc import x
+
+a = Symbol('a', real=True)
+B = AccumBounds
+
+
+def test_AccumBounds():
+    assert B(1, 2).args == (1, 2)
+    assert B(1, 2).delta is S.One
+    assert B(1, 2).mid == Rational(3, 2)
+    assert B(1, 3).is_real == True
+
+    assert B(1, 1) is S.One
+
+    assert B(1, 2) + 1 == B(2, 3)
+    assert 1 + B(1, 2) == B(2, 3)
+    assert B(1, 2) + B(2, 3) == B(3, 5)
+
+    assert -B(1, 2) == B(-2, -1)
+
+    assert B(1, 2) - 1 == B(0, 1)
+    assert 1 - B(1, 2) == B(-1, 0)
+    assert B(2, 3) - B(1, 2) == B(0, 2)
+
+    assert x + B(1, 2) == Add(B(1, 2), x)
+    assert a + B(1, 2) == B(1 + a, 2 + a)
+    assert B(1, 2) - x == Add(B(1, 2), -x)
+
+    assert B(-oo, 1) + oo == B(-oo, oo)
+    assert B(1, oo) + oo is oo
+    assert B(1, oo) - oo == B(-oo, oo)
+    assert (-oo - B(-1, oo)) is -oo
+    assert B(-oo, 1) - oo is -oo
+
+    assert B(1, oo) - oo == B(-oo, oo)
+    assert B(-oo, 1) - (-oo) == B(-oo, oo)
+    assert (oo - B(1, oo)) == B(-oo, oo)
+    assert (-oo - B(1, oo)) is -oo
+
+    assert B(1, 2)/2 == B(S.Half, 1)
+    assert 2/B(2, 3) == B(Rational(2, 3), 1)
+    assert 1/B(-1, 1) == B(-oo, oo)
+
+    assert abs(B(1, 2)) == B(1, 2)
+    assert abs(B(-2, -1)) == B(1, 2)
+    assert abs(B(-2, 1)) == B(0, 2)
+    assert abs(B(-1, 2)) == B(0, 2)
+    c = Symbol('c')
+    raises(ValueError, lambda: B(0, c))
+    raises(ValueError, lambda: B(1, -1))
+    r = Symbol('r', real=True)
+    raises(ValueError, lambda: B(r, r - 1))
+
+
+def test_AccumBounds_mul():
+    assert B(1, 2)*2 == B(2, 4)
+    assert 2*B(1, 2) == B(2, 4)
+    assert B(1, 2)*B(2, 3) == B(2, 6)
+    assert B(0, 2)*B(2, oo) == B(0, oo)
+    l, r = B(-oo, oo), B(-a, a)
+    assert l*r == B(-oo, oo)
+    assert r*l == B(-oo, oo)
+    l, r = B(1, oo), B(-3, -2)
+    assert l*r == B(-oo, -2)
+    assert r*l == B(-oo, -2)
+    assert B(1, 2)*0 == 0
+    assert B(1, oo)*0 == B(0, oo)
+    assert B(-oo, 1)*0 == B(-oo, 0)
+    assert B(-oo, oo)*0 == B(-oo, oo)
+
+    assert B(1, 2)*x == Mul(B(1, 2), x, evaluate=False)
+
+    assert B(0, 2)*oo == B(0, oo)
+    assert B(-2, 0)*oo == B(-oo, 0)
+    assert B(0, 2)*(-oo) == B(-oo, 0)
+    assert B(-2, 0)*(-oo) == B(0, oo)
+    assert B(-1, 1)*oo == B(-oo, oo)
+    assert B(-1, 1)*(-oo) == B(-oo, oo)
+    assert B(-oo, oo)*oo == B(-oo, oo)
+
+
+def test_AccumBounds_div():
+    assert B(-1, 3)/B(3, 4) == B(Rational(-1, 3), 1)
+    assert B(-2, 4)/B(-3, 4) == B(-oo, oo)
+    assert B(-3, -2)/B(-4, 0) == B(S.Half, oo)
+
+    # these two tests can have a better answer
+    # after Union of B is improved
+    assert B(-3, -2)/B(-2, 1) == B(-oo, oo)
+    assert B(2, 3)/B(-2, 2) == B(-oo, oo)
+
+    assert B(-3, -2)/B(0, 4) == B(-oo, Rational(-1, 2))
+    assert B(2, 4)/B(-3, 0) == B(-oo, Rational(-2, 3))
+    assert B(2, 4)/B(0, 3) == B(Rational(2, 3), oo)
+
+    assert B(0, 1)/B(0, 1) == B(0, oo)
+    assert B(-1, 0)/B(0, 1) == B(-oo, 0)
+    assert B(-1, 2)/B(-2, 2) == B(-oo, oo)
+
+    assert 1/B(-1, 2) == B(-oo, oo)
+    assert 1/B(0, 2) == B(S.Half, oo)
+    assert (-1)/B(0, 2) == B(-oo, Rational(-1, 2))
+    assert 1/B(-oo, 0) == B(-oo, 0)
+    assert 1/B(-1, 0) == B(-oo, -1)
+    assert (-2)/B(-oo, 0) == B(0, oo)
+    assert 1/B(-oo, -1) == B(-1, 0)
+
+    assert B(1, 2)/a == Mul(B(1, 2), 1/a, evaluate=False)
+
+    assert B(1, 2)/0 == B(1, 2)*zoo
+    assert B(1, oo)/oo == B(0, oo)
+    assert B(1, oo)/(-oo) == B(-oo, 0)
+    assert B(-oo, -1)/oo == B(-oo, 0)
+    assert B(-oo, -1)/(-oo) == B(0, oo)
+    assert B(-oo, oo)/oo == B(-oo, oo)
+    assert B(-oo, oo)/(-oo) == B(-oo, oo)
+    assert B(-1, oo)/oo == B(0, oo)
+    assert B(-1, oo)/(-oo) == B(-oo, 0)
+    assert B(-oo, 1)/oo == B(-oo, 0)
+    assert B(-oo, 1)/(-oo) == B(0, oo)
+
+
+def test_issue_18795():
+    r = Symbol('r', real=True)
+    a = B(-1,1)
+    c = B(7, oo)
+    b = B(-oo, oo)
+    assert c - tan(r) == B(7-tan(r), oo)
+    assert b + tan(r) == B(-oo, oo)
+    assert (a + r)/a == B(-oo, oo)*B(r - 1, r + 1)
+    assert (b + a)/a == B(-oo, oo)
+
+
+def test_AccumBounds_func():
+    assert (x**2 + 2*x + 1).subs(x, B(-1, 1)) == B(-1, 4)
+    assert exp(B(0, 1)) == B(1, E)
+    assert exp(B(-oo, oo)) == B(0, oo)
+    assert log(B(3, 6)) == B(log(3), log(6))
+
+
+@XFAIL
+def test_AccumBounds_powf():
+    nn = Symbol('nn', nonnegative=True)
+    assert B(1 + nn, 2 + nn)**B(1, 2) == B(1 + nn, (2 + nn)**2)
+    i = Symbol('i', integer=True, negative=True)
+    assert B(1, 2)**i == B(2**i, 1)
+
+
+def test_AccumBounds_pow():
+    assert B(0, 2)**2 == B(0, 4)
+    assert B(-1, 1)**2 == B(0, 1)
+    assert B(1, 2)**2 == B(1, 4)
+    assert B(-1, 2)**3 == B(-1, 8)
+    assert B(-1, 1)**0 == 1
+
+    assert B(1, 2)**Rational(5, 2) == B(1, 4*sqrt(2))
+    assert B(0, 2)**S.Half == B(0, sqrt(2))
+
+    neg = Symbol('neg', negative=True)
+    assert unchanged(Pow, B(neg, 1), S.Half)
+    nn = Symbol('nn', nonnegative=True)
+    assert B(nn, nn + 1)**S.Half == B(sqrt(nn), sqrt(nn + 1))
+    assert B(nn, nn + 1)**nn == B(nn**nn, (nn + 1)**nn)
+    assert unchanged(Pow, B(nn, nn + 1), x)
+    i = Symbol('i', integer=True)
+    assert B(1, 2)**i == B(Min(1, 2**i), Max(1, 2**i))
+    i = Symbol('i', integer=True, nonnegative=True)
+    assert B(1, 2)**i == B(1, 2**i)
+    assert B(0, 1)**i == B(0**i, 1)
+
+    assert B(1, 5)**(-2) == B(Rational(1, 25), 1)
+    assert B(-1, 3)**(-2) == B(0, oo)
+    assert B(0, 2)**(-3) == B(Rational(1, 8), oo)
+    assert B(-2, 0)**(-3) == B(-oo, -Rational(1, 8))
+    assert B(0, 2)**(-2) == B(Rational(1, 4), oo)
+    assert B(-1, 2)**(-3) == B(-oo, oo)
+    assert B(-3, -2)**(-3) == B(Rational(-1, 8), Rational(-1, 27))
+    assert B(-3, -2)**(-2) == B(Rational(1, 9), Rational(1, 4))
+    assert B(0, oo)**S.Half == B(0, oo)
+    assert B(-oo, 0)**(-2) == B(0, oo)
+    assert B(-2, 0)**(-2) == B(Rational(1, 4), oo)
+
+    assert B(Rational(1, 3), S.Half)**oo is S.Zero
+    assert B(0, S.Half)**oo is S.Zero
+    assert B(S.Half, 1)**oo == B(0, oo)
+    assert B(0, 1)**oo == B(0, oo)
+    assert B(2, 3)**oo is oo
+    assert B(1, 2)**oo == B(0, oo)
+    assert B(S.Half, 3)**oo == B(0, oo)
+    assert B(Rational(-1, 3), Rational(-1, 4))**oo is S.Zero
+    assert B(-1, Rational(-1, 2))**oo is S.NaN
+    assert B(-3, -2)**oo is zoo
+    assert B(-2, -1)**oo is S.NaN
+    assert B(-2, Rational(-1, 2))**oo is S.NaN
+    assert B(Rational(-1, 2), S.Half)**oo is S.Zero
+    assert B(Rational(-1, 2), 1)**oo == B(0, oo)
+    assert B(Rational(-2, 3), 2)**oo == B(0, oo)
+    assert B(-1, 1)**oo == B(-oo, oo)
+    assert B(-1, S.Half)**oo == B(-oo, oo)
+    assert B(-1, 2)**oo == B(-oo, oo)
+    assert B(-2, S.Half)**oo == B(-oo, oo)
+
+    assert B(1, 2)**x == Pow(B(1, 2), x, evaluate=False)
+
+    assert B(2, 3)**(-oo) is S.Zero
+    assert B(0, 2)**(-oo) == B(0, oo)
+    assert B(-1, 2)**(-oo) == B(-oo, oo)
+
+    assert (tan(x)**sin(2*x)).subs(x, B(0, pi/2)) == \
+        Pow(B(-oo, oo), B(0, 1))
+
+
+def test_AccumBounds_exponent():
+    # base is 0
+    z = 0**B(a, a + S.Half)
+    assert z.subs(a, 0) == B(0, 1)
+    assert z.subs(a, 1) == 0
+    p = z.subs(a, -1)
+    assert p.is_Pow and p.args == (0, B(-1, -S.Half))
+    # base > 0
+    #   when base is 1 the type of bounds does not matter
+    assert 1**B(a, a + 1) == 1
+    #  otherwise we need to know if 0 is in the bounds
+    assert S.Half**B(-2, 2) == B(S(1)/4, 4)
+    assert 2**B(-2, 2) == B(S(1)/4, 4)
+
+    # +eps may introduce +oo
+    # if there is a negative integer exponent
+    assert B(0, 1)**B(S(1)/2, 1) == B(0, 1)
+    assert B(0, 1)**B(0, 1) == B(0, 1)
+
+    # positive bases have positive bounds
+    assert B(2, 3)**B(-3, -2) == B(S(1)/27, S(1)/4)
+    assert B(2, 3)**B(-3, 2) == B(S(1)/27, 9)
+
+    # bounds generating imaginary parts unevaluated
+    assert unchanged(Pow, B(-1, 1), B(1, 2))
+    assert B(0, S(1)/2)**B(1, oo) == B(0, S(1)/2)
+    assert B(0, 1)**B(1, oo) == B(0, oo)
+    assert B(0, 2)**B(1, oo) == B(0, oo)
+    assert B(0, oo)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 1)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 1)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, 1)**B(-oo, oo) == B(0, oo)
+    assert B(S(1)/2, 2)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 2)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, 2)**B(-oo, oo) == B(0, oo)
+    assert B(S(1)/2, oo)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, oo)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, oo)**B(-oo, oo) == B(0, oo)
+    assert B(1, 2)**B(1, oo) == B(0, oo)
+    assert B(1, 2)**B(-oo, -1) == B(0, oo)
+    assert B(1, 2)**B(-oo, oo) == B(0, oo)
+    assert B(1, oo)**B(1, oo) == B(0, oo)
+    assert B(1, oo)**B(-oo, -1) == B(0, oo)
+    assert B(1, oo)**B(-oo, oo) == B(0, oo)
+    assert B(2, oo)**B(1, oo) == B(2, oo)
+    assert B(2, oo)**B(-oo, -1) == B(0, S(1)/2)
+    assert B(2, oo)**B(-oo, oo) == B(0, oo)
+
+
+def test_comparison_AccumBounds():
+    assert (B(1, 3) < 4) == S.true
+    assert (B(1, 3) < -1) == S.false
+    assert (B(1, 3) < 2).rel_op == '<'
+    assert (B(1, 3) <= 2).rel_op == '<='
+
+    assert (B(1, 3) > 4) == S.false
+    assert (B(1, 3) > -1) == S.true
+    assert (B(1, 3) > 2).rel_op == '>'
+    assert (B(1, 3) >= 2).rel_op == '>='
+
+    assert (B(1, 3) < B(4, 6)) == S.true
+    assert (B(1, 3) < B(2, 4)).rel_op == '<'
+    assert (B(1, 3) < B(-2, 0)) == S.false
+
+    assert (B(1, 3) <= B(4, 6)) == S.true
+    assert (B(1, 3) <= B(-2, 0)) == S.false
+
+    assert (B(1, 3) > B(4, 6)) == S.false
+    assert (B(1, 3) > B(-2, 0)) == S.true
+
+    assert (B(1, 3) >= B(4, 6)) == S.false
+    assert (B(1, 3) >= B(-2, 0)) == S.true
+
+    # issue 13499
+    assert (cos(x) > 0).subs(x, oo) == (B(-1, 1) > 0)
+
+    c = Symbol('c')
+    raises(TypeError, lambda: (B(0, 1) < c))
+    raises(TypeError, lambda: (B(0, 1) <= c))
+    raises(TypeError, lambda: (B(0, 1) > c))
+    raises(TypeError, lambda: (B(0, 1) >= c))
+
+
+def test_contains_AccumBounds():
+    assert (1 in B(1, 2)) == S.true
+    raises(TypeError, lambda: a in B(1, 2))
+    assert 0 in B(-1, 0)
+    raises(TypeError, lambda:
+        (cos(1)**2 + sin(1)**2 - 1) in B(-1, 0))
+    assert (-oo in B(1, oo)) == S.true
+    assert (oo in B(-oo, 0)) == S.true
+
+    # issue 13159
+    assert Mul(0, B(-1, 1)) == Mul(B(-1, 1), 0) == 0
+    import itertools
+    for perm in itertools.permutations([0, B(-1, 1), x]):
+        assert Mul(*perm) == 0
+
+
+def test_intersection_AccumBounds():
+    assert B(0, 3).intersection(B(1, 2)) == B(1, 2)
+    assert B(0, 3).intersection(B(1, 4)) == B(1, 3)
+    assert B(0, 3).intersection(B(-1, 2)) == B(0, 2)
+    assert B(0, 3).intersection(B(-1, 4)) == B(0, 3)
+    assert B(0, 1).intersection(B(2, 3)) == S.EmptySet
+    raises(TypeError, lambda: B(0, 3).intersection(1))
+
+
+def test_union_AccumBounds():
+    assert B(0, 3).union(B(1, 2)) == B(0, 3)
+    assert B(0, 3).union(B(1, 4)) == B(0, 4)
+    assert B(0, 3).union(B(-1, 2)) == B(-1, 3)
+    assert B(0, 3).union(B(-1, 4)) == B(-1, 4)
+    raises(TypeError, lambda: B(0, 3).union(1))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/tests/test_euler.py

@@ -0,0 +1,74 @@
+from sympy.core.function import (Derivative as D, Function)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import raises
+from sympy.calculus.euler import euler_equations as euler
+
+
+def test_euler_interface():
+    x = Function('x')
+    y = Symbol('y')
+    t = Symbol('t')
+    raises(TypeError, lambda: euler())
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [x(t), y]))
+    raises(ValueError, lambda: euler(D(x(t), t)*x(y), [x(t), x(y)]))
+    raises(TypeError, lambda: euler(D(x(t), t)**2, x(0)))
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [t]))
+    assert euler(D(x(t), t)**2/2, {x(t)}) == [Eq(-D(x(t), t, t), 0)]
+    assert euler(D(x(t), t)**2/2, x(t), {t}) == [Eq(-D(x(t), t, t), 0)]
+
+
+def test_euler_pendulum():
+    x = Function('x')
+    t = Symbol('t')
+    L = D(x(t), t)**2/2 + cos(x(t))
+    assert euler(L, x(t), t) == [Eq(-sin(x(t)) - D(x(t), t, t), 0)]
+
+
+def test_euler_henonheiles():
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = sum(D(z(t), t)**2/2 - z(t)**2/2 for z in [x, y])
+    L += -x(t)**2*y(t) + y(t)**3/3
+    assert euler(L, [x(t), y(t)], t) == [Eq(-2*x(t)*y(t) - x(t) -
+                                            D(x(t), t, t), 0),
+                                         Eq(-x(t)**2 + y(t)**2 -
+                                            y(t) - D(y(t), t, t), 0)]
+
+
+def test_euler_sineg():
+    psi = Function('psi')
+    t = Symbol('t')
+    x = Symbol('x')
+    L = D(psi(t, x), t)**2/2 - D(psi(t, x), x)**2/2 + cos(psi(t, x))
+    assert euler(L, psi(t, x), [t, x]) == [Eq(-sin(psi(t, x)) -
+                                              D(psi(t, x), t, t) +
+                                              D(psi(t, x), x, x), 0)]
+
+
+def test_euler_high_order():
+    # an example from hep-th/0309038
+    m = Symbol('m')
+    k = Symbol('k')
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = (m*D(x(t), t)**2/2 + m*D(y(t), t)**2/2 -
+         k*D(x(t), t)*D(y(t), t, t) + k*D(y(t), t)*D(x(t), t, t))
+    assert euler(L, [x(t), y(t)]) == [Eq(2*k*D(y(t), t, t, t) -
+                                         m*D(x(t), t, t), 0),
+                                      Eq(-2*k*D(x(t), t, t, t) -
+                                         m*D(y(t), t, t), 0)]
+
+    w = Symbol('w')
+    L = D(x(t, w), t, w)**2/2
+    assert euler(L) == [Eq(D(x(t, w), t, t, w, w), 0)]
+
+def test_issue_18653():
+    x, y, z = symbols("x y z")
+    f, g, h = symbols("f g h", cls=Function, args=(x, y))
+    f, g, h = f(), g(), h()
+    expr2 = f.diff(x)*h.diff(z)
+    assert euler(expr2, (f,), (x, y)) == []

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/tests/test_finite_diff.py

@@ -0,0 +1,164 @@
+from itertools import product
+
+from sympy.core.function import (Function, diff)
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.calculus.finite_diff import (
+    apply_finite_diff, differentiate_finite, finite_diff_weights,
+    _as_finite_diff
+)
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+def test_apply_finite_diff():
+    x, h = symbols('x h')
+    f = Function('f')
+    assert (apply_finite_diff(1, [x-h, x+h], [f(x-h), f(x+h)], x) -
+            (f(x+h)-f(x-h))/(2*h)).simplify() == 0
+
+    assert (apply_finite_diff(1, [5, 6, 7], [f(5), f(6), f(7)], 5) -
+            (Rational(-3, 2)*f(5) + 2*f(6) - S.Half*f(7))).simplify() == 0
+    raises(ValueError, lambda: apply_finite_diff(1, [x, h], [f(x)]))
+
+
+def test_finite_diff_weights():
+
+    d = finite_diff_weights(1, [5, 6, 7], 5)
+    assert d[1][2] == [Rational(-3, 2), 2, Rational(-1, 2)]
+
+    # Table 1, p. 702 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [0, 1, -1, 2, -2, 3, -3, 4, -4]
+
+    # d holds all coefficients
+    d = finite_diff_weights(4, xl, S.Zero)
+
+    # Zeroeth derivative
+    for i in range(5):
+        assert d[0][i] == [S.One] + [S.Zero]*8
+
+    # First derivative
+    assert d[1][0] == [S.Zero]*9
+    assert d[1][2] == [S.Zero, S.Half, Rational(-1, 2)] + [S.Zero]*6
+    assert d[1][4] == [S.Zero, Rational(2, 3), Rational(-2, 3), Rational(-1, 12), Rational(1, 12)] + [S.Zero]*4
+    assert d[1][6] == [S.Zero, Rational(3, 4), Rational(-3, 4), Rational(-3, 20), Rational(3, 20),
+                       Rational(1, 60), Rational(-1, 60)] + [S.Zero]*2
+    assert d[1][8] == [S.Zero, Rational(4, 5), Rational(-4, 5), Rational(-1, 5), Rational(1, 5),
+                       Rational(4, 105), Rational(-4, 105), Rational(-1, 280), Rational(1, 280)]
+
+    # Second derivative
+    for i in range(2):
+        assert d[2][i] == [S.Zero]*9
+    assert d[2][2] == [-S(2), S.One, S.One] + [S.Zero]*6
+    assert d[2][4] == [Rational(-5, 2), Rational(4, 3), Rational(4, 3), Rational(-1, 12), Rational(-1, 12)] + [S.Zero]*4
+    assert d[2][6] == [Rational(-49, 18), Rational(3, 2), Rational(3, 2), Rational(-3, 20), Rational(-3, 20),
+                       Rational(1, 90), Rational(1, 90)] + [S.Zero]*2
+    assert d[2][8] == [Rational(-205, 72), Rational(8, 5), Rational(8, 5), Rational(-1, 5), Rational(-1, 5),
+                       Rational(8, 315), Rational(8, 315), Rational(-1, 560), Rational(-1, 560)]
+
+    # Third derivative
+    for i in range(3):
+        assert d[3][i] == [S.Zero]*9
+    assert d[3][4] == [S.Zero, -S.One, S.One, S.Half, Rational(-1, 2)] + [S.Zero]*4
+    assert d[3][6] == [S.Zero, Rational(-13, 8), Rational(13, 8), S.One, -S.One,
+                       Rational(-1, 8), Rational(1, 8)] + [S.Zero]*2
+    assert d[3][8] == [S.Zero, Rational(-61, 30), Rational(61, 30), Rational(169, 120), Rational(-169, 120),
+                       Rational(-3, 10), Rational(3, 10), Rational(7, 240), Rational(-7, 240)]
+
+    # Fourth derivative
+    for i in range(4):
+        assert d[4][i] == [S.Zero]*9
+    assert d[4][4] == [S(6), -S(4), -S(4), S.One, S.One] + [S.Zero]*4
+    assert d[4][6] == [Rational(28, 3), Rational(-13, 2), Rational(-13, 2), S(2), S(2),
+                       Rational(-1, 6), Rational(-1, 6)] + [S.Zero]*2
+    assert d[4][8] == [Rational(91, 8), Rational(-122, 15), Rational(-122, 15), Rational(169, 60), Rational(169, 60),
+                       Rational(-2, 5), Rational(-2, 5), Rational(7, 240), Rational(7, 240)]
+
+    # Table 2, p. 703 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [[j/S(2) for j in list(range(-i*2+1, 0, 2))+list(range(1, i*2+1, 2))]
+          for i in range(1, 5)]
+
+    # d holds all coefficients
+    d = [finite_diff_weights({0: 1, 1: 2, 2: 4, 3: 4}[i], xl[i], 0) for
+         i in range(4)]
+
+    # Zeroth derivative
+    assert d[0][0][1] == [S.Half, S.Half]
+    assert d[1][0][3] == [Rational(-1, 16), Rational(9, 16), Rational(9, 16), Rational(-1, 16)]
+    assert d[2][0][5] == [Rational(3, 256), Rational(-25, 256), Rational(75, 128), Rational(75, 128),
+                          Rational(-25, 256), Rational(3, 256)]
+    assert d[3][0][7] == [Rational(-5, 2048), Rational(49, 2048), Rational(-245, 2048), Rational(1225, 2048),
+                          Rational(1225, 2048), Rational(-245, 2048), Rational(49, 2048), Rational(-5, 2048)]
+
+    # First derivative
+    assert d[0][1][1] == [-S.One, S.One]
+    assert d[1][1][3] == [Rational(1, 24), Rational(-9, 8), Rational(9, 8), Rational(-1, 24)]
+    assert d[2][1][5] == [Rational(-3, 640), Rational(25, 384), Rational(-75, 64),
+                          Rational(75, 64), Rational(-25, 384), Rational(3, 640)]
+    assert d[3][1][7] == [Rational(5, 7168), Rational(-49, 5120),
+                          Rational(245, 3072), Rational(-1225, 1024),
+                          Rational(1225, 1024), Rational(-245, 3072),
+                          Rational(49, 5120), Rational(-5, 7168)]
+
+    # Reasonably the rest of the table is also correct... (testing of that
+    # deemed excessive at the moment)
+    raises(ValueError, lambda: finite_diff_weights(-1, [1, 2]))
+    raises(ValueError, lambda: finite_diff_weights(1.2, [1, 2]))
+    x = symbols('x')
+    raises(ValueError, lambda: finite_diff_weights(x, [1, 2]))
+
+
+def test_as_finite_diff():
+    x = symbols('x')
+    f = Function('f')
+    dx = Function('dx')
+
+    _as_finite_diff(f(x).diff(x), [x-2, x-1, x, x+1, x+2])
+
+    # Use of undefined functions in ``points``
+    df_true = -f(x+dx(x)/2-dx(x+dx(x)/2)/2) / dx(x+dx(x)/2) \
+              + f(x+dx(x)/2+dx(x+dx(x)/2)/2) / dx(x+dx(x)/2)
+    df_test = diff(f(x), x).as_finite_difference(points=dx(x), x0=x+dx(x)/2)
+    assert (df_test - df_true).simplify() == 0
+
+
+def test_differentiate_finite():
+    x, y, h = symbols('x y h')
+    f = Function('f')
+    with warns_deprecated_sympy():
+        res0 = differentiate_finite(f(x, y) + exp(42), x, y, evaluate=True)
+    xm, xp, ym, yp = [v + sign*S.Half for v, sign in product([x, y], [-1, 1])]
+    ref0 = f(xm, ym) + f(xp, yp) - f(xm, yp) - f(xp, ym)
+    assert (res0 - ref0).simplify() == 0
+
+    g = Function('g')
+    with warns_deprecated_sympy():
+        res1 = differentiate_finite(f(x)*g(x) + 42, x, evaluate=True)
+    ref1 = (-f(x - S.Half) + f(x + S.Half))*g(x) + \
+           (-g(x - S.Half) + g(x + S.Half))*f(x)
+    assert (res1 - ref1).simplify() == 0
+
+    res2 = differentiate_finite(f(x) + x**3 + 42, x, points=[x-1, x+1])
+    ref2 = (f(x + 1) + (x + 1)**3 - f(x - 1) - (x - 1)**3)/2
+    assert (res2 - ref2).simplify() == 0
+    raises(TypeError, lambda: differentiate_finite(f(x)*g(x), x,
+                                                   pints=[x-1, x+1]))
+
+    res3 = differentiate_finite(f(x)*g(x).diff(x), x)
+    ref3 = (-g(x) + g(x + 1))*f(x + S.Half) - (g(x) - g(x - 1))*f(x - S.Half)
+    assert res3 == ref3
+
+    res4 = differentiate_finite(f(x)*g(x).diff(x).diff(x), x)
+    ref4 = -((g(x - Rational(3, 2)) - 2*g(x - S.Half) + g(x + S.Half))*f(x - S.Half)) \
+           + (g(x - S.Half) - 2*g(x + S.Half) + g(x + Rational(3, 2)))*f(x + S.Half)
+    assert res4 == ref4
+
+    res5_expr = f(x).diff(x)*g(x).diff(x)
+    res5 = differentiate_finite(res5_expr, points=[x-h, x, x+h])
+    ref5 = (-2*f(x)/h + f(-h + x)/(2*h) + 3*f(h + x)/(2*h))*(-2*g(x)/h + g(-h + x)/(2*h) \
+           + 3*g(h + x)/(2*h))/(2*h) - (2*f(x)/h - 3*f(-h + x)/(2*h) - \
+           f(h + x)/(2*h))*(2*g(x)/h - 3*g(-h + x)/(2*h) - g(h + x)/(2*h))/(2*h)
+    assert res5 == ref5

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/tests/test_singularities.py

@@ -0,0 +1,122 @@
+from sympy.core.numbers import (I, Rational, pi, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.function import Lambda
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import sec, csc
+from sympy.functions.elementary.hyperbolic import (coth, sech,
+                                                   atanh, asech, acoth, acsch)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.calculus.singularities import (
+    singularities,
+    is_increasing,
+    is_strictly_increasing,
+    is_decreasing,
+    is_strictly_decreasing,
+    is_monotonic
+)
+from sympy.sets import Interval, FiniteSet, Union, ImageSet
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+
+def test_singularities():
+    x = Symbol('x')
+    assert singularities(x**2, x) == S.EmptySet
+    assert singularities(x/(x**2 + 3*x + 2), x) == FiniteSet(-2, -1)
+    assert singularities(1/(x**2 + 1), x) == FiniteSet(I, -I)
+    assert singularities(x/(x**3 + 1), x) == \
+        FiniteSet(-1, (1 - sqrt(3) * I) / 2, (1 + sqrt(3) * I) / 2)
+    assert singularities(1/(y**2 + 2*I*y + 1), y) == \
+        FiniteSet(-I + sqrt(2)*I, -I - sqrt(2)*I)
+    _n = Dummy('n')
+    assert singularities(sech(x), x).dummy_eq(Union(
+        ImageSet(Lambda(_n, 2*_n*I*pi + I*pi/2), S.Integers),
+        ImageSet(Lambda(_n, 2*_n*I*pi + 3*I*pi/2), S.Integers)))
+    assert singularities(coth(x), x).dummy_eq(Union(
+        ImageSet(Lambda(_n, 2*_n*I*pi + I*pi), S.Integers),
+        ImageSet(Lambda(_n, 2*_n*I*pi), S.Integers)))
+    assert singularities(atanh(x), x) == FiniteSet(-1, 1)
+    assert singularities(acoth(x), x) == FiniteSet(-1, 1)
+    assert singularities(asech(x), x) == FiniteSet(0)
+    assert singularities(acsch(x), x) == FiniteSet(0)
+
+    x = Symbol('x', real=True)
+    assert singularities(1/(x**2 + 1), x) == S.EmptySet
+    assert singularities(exp(1/x), x, S.Reals) == FiniteSet(0)
+    assert singularities(exp(1/x), x, Interval(1, 2)) == S.EmptySet
+    assert singularities(log((x - 2)**2), x, Interval(1, 3)) == FiniteSet(2)
+    raises(NotImplementedError, lambda: singularities(x**-oo, x))
+    assert singularities(sec(x), x, Interval(0, 3*pi)) == FiniteSet(
+        pi/2, 3*pi/2, 5*pi/2)
+    assert singularities(csc(x), x, Interval(0, 3*pi)) == FiniteSet(
+        0, pi, 2*pi, 3*pi)
+
+
+def test_is_increasing():
+    """Test whether is_increasing returns correct value."""
+    a = Symbol('a', negative=True)
+
+    assert is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert is_increasing(-x**2, Interval(-oo, 0))
+    assert not is_increasing(-x**2, Interval(0, oo))
+    assert not is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    assert is_increasing(x**2 + y, Interval(1, oo), x)
+    assert is_increasing(-x**2*a, Interval(1, oo), x)
+    assert is_increasing(1)
+
+    assert is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3)) is False
+
+
+def test_is_strictly_increasing():
+    """Test whether is_strictly_increasing returns correct value."""
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    assert not is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    assert not is_strictly_increasing(-x**2, Interval(0, oo))
+    assert not is_strictly_decreasing(1)
+
+    assert is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3)) is False
+
+
+def test_is_decreasing():
+    """Test whether is_decreasing returns correct value."""
+    b = Symbol('b', positive=True)
+
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_decreasing(-x**2*b, Interval(-oo, 0), x)
+
+
+def test_is_strictly_decreasing():
+    """Test whether is_strictly_decreasing returns correct value."""
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_strictly_decreasing(
+        1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_strictly_decreasing(1)
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+
+
+def test_is_monotonic():
+    """Test whether is_monotonic returns correct value."""
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert not is_monotonic(-x**2, S.Reals)
+    assert is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    raises(NotImplementedError, lambda: is_monotonic(x**2 + y + 1))
+
+
+def test_issue_23401():
+    x = Symbol('x')
+    expr = (x + 1)/(-1.0e-3*x**2 + 0.1*x + 0.1)
+    assert is_increasing(expr, Interval(1,2), x)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/tests/test_util.py

@@ -0,0 +1,392 @@
+from sympy.core.function import Lambda
+from sympy.core.numbers import (E, I, Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.complexes import (Abs, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import frac
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    cos, cot, csc, sec, sin, tan, asin, acos, atan, acot, asec, acsc)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+    sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.error_functions import expint
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.simplify.simplify import simplify
+from sympy.calculus.util import (function_range, continuous_domain, not_empty_in,
+                                 periodicity, lcim, is_convex,
+                                 stationary_points, minimum, maximum)
+from sympy.sets.sets import (Interval, FiniteSet, Complement, Union)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.conditionset import ConditionSet
+from sympy.testing.pytest import XFAIL, raises, _both_exp_pow, slow
+from sympy.abc import x, y
+
+a = Symbol('a', real=True)
+
+def test_function_range():
+    assert function_range(sin(x), x, Interval(-pi/2, pi/2)
+        ) == Interval(-1, 1)
+    assert function_range(sin(x), x, Interval(0, pi)
+        ) == Interval(0, 1)
+    assert function_range(tan(x), x, Interval(0, pi)
+        ) == Interval(-oo, oo)
+    assert function_range(tan(x), x, Interval(pi/2, pi)
+        ) == Interval(-oo, 0)
+    assert function_range((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) == Union(Interval(-oo, Rational(2, 7)), Interval(Rational(8, 3), oo))
+    assert function_range(1/(x**2), x, Interval(-1, 1)
+        ) == Interval(1, oo)
+    assert function_range(exp(x), x, Interval(-1, 1)
+        ) == Interval(exp(-1), exp(1))
+    assert function_range(log(x) - x, x, S.Reals
+        ) == Interval(-oo, -1)
+    assert function_range(sqrt(3*x - 1), x, Interval(0, 2)
+        ) == Interval(0, sqrt(5))
+    assert function_range(x*(x - 1) - (x**2 - x), x, S.Reals
+        ) == FiniteSet(0)
+    assert function_range(x*(x - 1) - (x**2 - x) + y, x, S.Reals
+        ) == FiniteSet(y)
+    assert function_range(sin(x), x, Union(Interval(-5, -3), FiniteSet(4))
+        ) == Union(Interval(-sin(3), 1), FiniteSet(sin(4)))
+    assert function_range(cos(x), x, Interval(-oo, -4)
+        ) == Interval(-1, 1)
+    assert function_range(cos(x), x, S.EmptySet) == S.EmptySet
+    assert function_range(x/sqrt(x**2+1), x, S.Reals) == Interval.open(-1,1)
+    raises(NotImplementedError, lambda : function_range(
+        exp(x)*(sin(x) - cos(x))/2 - x, x, S.Reals))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x) + x, x, S.Reals)) # issue 13273
+    raises(NotImplementedError, lambda : function_range(
+        log(x), x, S.Integers))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x)/2, x, S.Naturals))
+
+
+@slow
+def test_function_range1():
+    assert function_range(tan(x)**2 + tan(3*x)**2 + 1, x, S.Reals) == Interval(1,oo)
+
+
+def test_continuous_domain():
+    assert continuous_domain(sin(x), x, Interval(0, 2*pi)) == Interval(0, 2*pi)
+    assert continuous_domain(tan(x), x, Interval(0, 2*pi)) == \
+        Union(Interval(0, pi/2, False, True), Interval(pi/2, pi*Rational(3, 2), True, True),
+              Interval(pi*Rational(3, 2), 2*pi, True, False))
+    assert continuous_domain(cot(x), x, Interval(0, 2*pi)) == Union(
+        Interval.open(0, pi), Interval.open(pi, 2*pi))
+    assert continuous_domain((x - 1)/((x - 1)**2), x, S.Reals) == \
+        Union(Interval(-oo, 1, True, True), Interval(1, oo, True, True))
+    assert continuous_domain(log(x) + log(4*x - 1), x, S.Reals) == \
+        Interval(Rational(1, 4), oo, True, True)
+    assert continuous_domain(1/sqrt(x - 3), x, S.Reals) == Interval(3, oo, True, True)
+    assert continuous_domain(1/x - 2, x, S.Reals) == \
+        Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    assert continuous_domain(1/(x**2 - 4) + 2, x, S.Reals) == \
+        Union(Interval.open(-oo, -2), Interval.open(-2, 2), Interval.open(2, oo))
+    assert continuous_domain((x+1)**pi, x, S.Reals) == Interval(-1, oo)
+    assert continuous_domain((x+1)**(pi/2), x, S.Reals) == Interval(-1, oo)
+    assert continuous_domain(x**x, x, S.Reals) == Interval(0, oo)
+    assert continuous_domain((x+1)**log(x**2), x, S.Reals) == Union(
+        Interval.Ropen(-1, 0), Interval.open(0, oo))
+    domain = continuous_domain(log(tan(x)**2 + 1), x, S.Reals)
+    assert not domain.contains(3*pi/2)
+    assert domain.contains(5)
+    d = Symbol('d', even=True, zero=False)
+    assert continuous_domain(x**(1/d), x, S.Reals) == Interval(0, oo)
+    n = Dummy('n')
+    assert continuous_domain(1/sin(x), x, S.Reals).dummy_eq(Complement(
+        S.Reals, Union(ImageSet(Lambda(n, 2*n*pi + pi), S.Integers),
+                       ImageSet(Lambda(n, 2*n*pi), S.Integers))))
+    assert continuous_domain(sin(x) + cos(x), x, S.Reals) == S.Reals
+    assert continuous_domain(asin(x), x, S.Reals) == Interval(-1, 1) # issue #21786
+    assert continuous_domain(1/acos(log(x)), x, S.Reals) == Interval.Ropen(exp(-1), E)
+    assert continuous_domain(sinh(x)+cosh(x), x, S.Reals) == S.Reals
+    assert continuous_domain(tanh(x)+sech(x), x, S.Reals) == S.Reals
+    assert continuous_domain(atan(x)+asinh(x), x, S.Reals) == S.Reals
+    assert continuous_domain(acosh(x), x, S.Reals) == Interval(1, oo)
+    assert continuous_domain(atanh(x), x, S.Reals) == Interval.open(-1, 1)
+    assert continuous_domain(atanh(x)+acosh(x), x, S.Reals) == S.EmptySet
+    assert continuous_domain(asech(x), x, S.Reals) == Interval.Lopen(0, 1)
+    assert continuous_domain(acoth(x), x, S.Reals) == Union(
+        Interval.open(-oo, -1), Interval.open(1, oo))
+    assert continuous_domain(asec(x), x, S.Reals) == Union(
+        Interval(-oo, -1), Interval(1, oo))
+    assert continuous_domain(acsc(x), x, S.Reals) == Union(
+        Interval(-oo, -1), Interval(1, oo))
+    for f in (coth, acsch, csch):
+        assert continuous_domain(f(x), x, S.Reals) == Union(
+            Interval.open(-oo, 0), Interval.open(0, oo))
+    assert continuous_domain(acot(x), x, S.Reals).contains(0) == False
+    assert continuous_domain(1/(exp(x) - x), x, S.Reals) == Complement(
+        S.Reals, ConditionSet(x, Eq(-x + exp(x), 0), S.Reals))
+    assert continuous_domain(frac(x**2), x, Interval(-2,-1)) == Union(
+        Interval.open(-2, -sqrt(3)), Interval.open(-sqrt(2), -1),
+        Interval.open(-sqrt(3), -sqrt(2)))
+    assert continuous_domain(frac(x), x, S.Reals) == Complement(
+        S.Reals, S.Integers)
+    raises(NotImplementedError, lambda : continuous_domain(
+        1/(x**2+1), x, S.Complexes))
+    raises(NotImplementedError, lambda : continuous_domain(
+        gamma(x), x, Interval(-5,0)))
+    assert continuous_domain(x + gamma(pi), x, S.Reals) == S.Reals
+
+
+@XFAIL
+def test_continuous_domain_acot():
+    acot_cont = Piecewise((pi+acot(x), x<0), (acot(x), True))
+    assert continuous_domain(acot_cont, x, S.Reals) == S.Reals
+
+@XFAIL
+def test_continuous_domain_gamma():
+    assert continuous_domain(gamma(x), x, S.Reals).contains(-1) == False
+
+@XFAIL
+def test_continuous_domain_neg_power():
+    assert continuous_domain((x-2)**(1-x), x, S.Reals) == Interval.open(2, oo)
+
+
+def test_not_empty_in():
+    assert not_empty_in(FiniteSet(x, 2*x).intersect(Interval(1, 2, True, False)), x) == \
+        Interval(S.Half, 2, True, False)
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x) == \
+        Union(Interval(-sqrt(2), -1), Interval(1, 2))
+    assert not_empty_in(FiniteSet(x**2 + x, x).intersect(Interval(2, 4)), x) == \
+        Union(Interval(-sqrt(17)/2 - S.Half, -2),
+              Interval(1, Rational(-1, 2) + sqrt(17)/2), Interval(2, 4))
+    assert not_empty_in(FiniteSet(x/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(a/(a - 1)).intersect(S.Reals), a) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet((x**2 - 3*x + 2)/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(3, 4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(-oo, oo)
+    assert not_empty_in(FiniteSet(4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(S(3)/2, 2)
+    assert not_empty_in(FiniteSet(x/(x**2 - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(-1, 1))
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Union(Interval(1, 3, True, True),
+                                                           Interval(4, 5))), x) == \
+        Union(Interval(-sqrt(5), -2), Interval(-sqrt(3), -1, True, True),
+              Interval(1, 3, True, True), Interval(4, 5))
+    assert not_empty_in(FiniteSet(1).intersect(Interval(3, 4)), x) == S.EmptySet
+    assert not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) == \
+        Union(Interval(-2, -1, True, False), Interval(2, oo))
+    raises(ValueError, lambda: not_empty_in(x))
+    raises(ValueError, lambda: not_empty_in(Interval(0, 1), x))
+    raises(NotImplementedError,
+           lambda: not_empty_in(FiniteSet(x).intersect(S.Reals), x, a))
+
+
+@_both_exp_pow
+def test_periodicity():
+    assert periodicity(sin(2*x), x) == pi
+    assert periodicity((-2)*tan(4*x), x) == pi/4
+    assert periodicity(sin(x)**2, x) == 2*pi
+    assert periodicity(3**tan(3*x), x) == pi/3
+    assert periodicity(tan(x)*cos(x), x) == 2*pi
+    assert periodicity(sin(x)**(tan(x)), x) == 2*pi
+    assert periodicity(tan(x)*sec(x), x) == 2*pi
+    assert periodicity(sin(2*x)*cos(2*x) - y, x) == pi/2
+    assert periodicity(tan(x) + cot(x), x) == pi
+    assert periodicity(sin(x) - cos(2*x), x) == 2*pi
+    assert periodicity(sin(x) - 1, x) == 2*pi
+    assert periodicity(sin(4*x) + sin(x)*cos(x), x) == pi
+    assert periodicity(exp(sin(x)), x) == 2*pi
+    assert periodicity(log(cot(2*x)) - sin(cos(2*x)), x) == pi
+    assert periodicity(sin(2*x)*exp(tan(x) - csc(2*x)), x) == pi
+    assert periodicity(cos(sec(x) - csc(2*x)), x) == 2*pi
+    assert periodicity(tan(sin(2*x)), x) == pi
+    assert periodicity(2*tan(x)**2, x) == pi
+    assert periodicity(sin(x%4), x) == 4
+    assert periodicity(sin(x)%4, x) == 2*pi
+    assert periodicity(tan((3*x-2)%4), x) == Rational(4, 3)
+    assert periodicity((sqrt(2)*(x+1)+x) % 3, x) == 3 / (sqrt(2)+1)
+    assert periodicity((x**2+1) % x, x) is None
+    assert periodicity(sin(re(x)), x) == 2*pi
+    assert periodicity(sin(x)**2 + cos(x)**2, x) is S.Zero
+    assert periodicity(tan(x), y) is S.Zero
+    assert periodicity(sin(x) + I*cos(x), x) == 2*pi
+    assert periodicity(x - sin(2*y), y) == pi
+
+    assert periodicity(exp(x), x) is None
+    assert periodicity(exp(I*x), x) == 2*pi
+    assert periodicity(exp(I*a), a) == 2*pi
+    assert periodicity(exp(a), a) is None
+    assert periodicity(exp(log(sin(a) + I*cos(2*a)), evaluate=False), a) == 2*pi
+    assert periodicity(exp(log(sin(2*a) + I*cos(a)), evaluate=False), a) == 2*pi
+    assert periodicity(exp(sin(a)), a) == 2*pi
+    assert periodicity(exp(2*I*a), a) == pi
+    assert periodicity(exp(a + I*sin(a)), a) is None
+    assert periodicity(exp(cos(a/2) + sin(a)), a) == 4*pi
+    assert periodicity(log(x), x) is None
+    assert periodicity(exp(x)**sin(x), x) is None
+    assert periodicity(sin(x)**y, y) is None
+
+    assert periodicity(Abs(sin(Abs(sin(x)))), x) == pi
+    assert all(periodicity(Abs(f(x)), x) == pi for f in (
+        cos, sin, sec, csc, tan, cot))
+    assert periodicity(Abs(sin(tan(x))), x) == pi
+    assert periodicity(Abs(sin(sin(x) + tan(x))), x) == 2*pi
+    assert periodicity(sin(x) > S.Half, x) == 2*pi
+
+    assert periodicity(x > 2, x) is None
+    assert periodicity(x**3 - x**2 + 1, x) is None
+    assert periodicity(Abs(x), x) is None
+    assert periodicity(Abs(x**2 - 1), x) is None
+
+    assert periodicity((x**2 + 4)%2, x) is None
+    assert periodicity((E**x)%3, x) is None
+
+    assert periodicity(sin(expint(1, x))/expint(1, x), x) is None
+    # returning `None` for any Piecewise
+    p = Piecewise((0, x < -1), (x**2, x <= 1), (log(x), True))
+    assert periodicity(p, x) is None
+
+    m = MatrixSymbol('m', 3, 3)
+    raises(NotImplementedError, lambda: periodicity(sin(m), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m), m[0, 0]))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m[0, 0]))
+
+
+def test_periodicity_check():
+    assert periodicity(tan(x), x, check=True) == pi
+    assert periodicity(sin(x) + cos(x), x, check=True) == 2*pi
+    assert periodicity(sec(x), x) == 2*pi
+    assert periodicity(sin(x*y), x) == 2*pi/abs(y)
+    assert periodicity(Abs(sec(sec(x))), x) == pi
+
+
+def test_lcim():
+    assert lcim([S.Half, S(2), S(3)]) == 6
+    assert lcim([pi/2, pi/4, pi]) == pi
+    assert lcim([2*pi, pi/2]) == 2*pi
+    assert lcim([S.One, 2*pi]) is None
+    assert lcim([S(2) + 2*E, E/3 + Rational(1, 3), S.One + E]) == S(2) + 2*E
+
+
+def test_is_convex():
+    assert is_convex(1/x, x, domain=Interval.open(0, oo)) == True
+    assert is_convex(1/x, x, domain=Interval(-oo, 0)) == False
+    assert is_convex(x**2, x, domain=Interval(0, oo)) == True
+    assert is_convex(1/x**3, x, domain=Interval.Lopen(0, oo)) == True
+    assert is_convex(-1/x**3, x, domain=Interval.Ropen(-oo, 0)) == True
+    assert is_convex(log(x) ,x) == False
+    assert is_convex(x**2+y**2, x, y) == True
+    assert is_convex(cos(x) + cos(y), x) == False
+    assert is_convex(8*x**2 - 2*y**2, x, y) == False
+
+
+def test_stationary_points():
+    assert stationary_points(sin(x), x, Interval(-pi/2, pi/2)
+        ) == {-pi/2, pi/2}
+    assert  stationary_points(sin(x), x, Interval.Ropen(0, pi/4)
+        ) is S.EmptySet
+    assert stationary_points(tan(x), x,
+        ) is S.EmptySet
+    assert stationary_points(sin(x)*cos(x), x, Interval(0, pi)
+        ) == {pi/4, pi*Rational(3, 4)}
+    assert stationary_points(sec(x), x, Interval(0, pi)
+        ) == {0, pi}
+    assert stationary_points((x+3)*(x-2), x
+        ) == FiniteSet(Rational(-1, 2))
+    assert stationary_points((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) is S.EmptySet
+    assert stationary_points((x**2+3)/(x-2), x
+        ) == {2 - sqrt(7), 2 + sqrt(7)}
+    assert stationary_points((x**2+3)/(x-2), x, Interval(0, 5)
+        ) == {2 + sqrt(7)}
+    assert stationary_points(x**4 + x**3 - 5*x**2, x, S.Reals
+        ) == FiniteSet(-2, 0, Rational(5, 4))
+    assert stationary_points(exp(x), x
+        ) is S.EmptySet
+    assert stationary_points(log(x) - x, x, S.Reals
+        ) == {1}
+    assert stationary_points(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) == {0, -pi, pi}
+    assert stationary_points(y, x, S.Reals
+        ) == S.Reals
+    assert stationary_points(y, x, S.EmptySet) == S.EmptySet
+
+
+def test_maximum():
+    assert maximum(sin(x), x) is S.One
+    assert maximum(sin(x), x, Interval(0, 1)) == sin(1)
+    assert maximum(tan(x), x) is oo
+    assert maximum(tan(x), x, Interval(-pi/4, pi/4)) is S.One
+    assert maximum(sin(x)*cos(x), x, S.Reals) == S.Half
+    assert simplify(maximum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == sqrt(2)/4
+    assert maximum((x+3)*(x-2), x) is oo
+    assert maximum((x+3)*(x-2), x, Interval(-5, 0)) == S(14)
+    assert maximum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(2, 7)
+    assert simplify(maximum(-x**4-x**3+x**2+10, x)
+        ) == 41*sqrt(41)/512 + Rational(5419, 512)
+    assert maximum(exp(x), x, Interval(-oo, 2)) == exp(2)
+    assert maximum(log(x) - x, x, S.Reals) is S.NegativeOne
+    assert maximum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.One
+    assert maximum(cos(x)-sin(x), x, S.Reals) == sqrt(2)
+    assert maximum(y, x, S.Reals) == y
+    assert maximum(abs(a**3 + a), a, Interval(0, 2)) == 10
+    assert maximum(abs(60*a**3 + 24*a), a, Interval(0, 2)) == 528
+    assert maximum(abs(12*a*(5*a**2 + 2)), a, Interval(0, 2)) == 528
+    assert maximum(x/sqrt(x**2+1), x, S.Reals) == 1
+
+    raises(ValueError, lambda : maximum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), sin(x)))
+    raises(ValueError, lambda : maximum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), S.One))
+
+
+def test_minimum():
+    assert minimum(sin(x), x) is S.NegativeOne
+    assert minimum(sin(x), x, Interval(1, 4)) == sin(4)
+    assert minimum(tan(x), x) is -oo
+    assert minimum(tan(x), x, Interval(-pi/4, pi/4)) is S.NegativeOne
+    assert minimum(sin(x)*cos(x), x, S.Reals) == Rational(-1, 2)
+    assert simplify(minimum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == -sqrt(2)/4
+    assert minimum((x+3)*(x-2), x) == Rational(-25, 4)
+    assert minimum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(-3, 2)
+    assert minimum(x**4-x**3+x**2+10, x) == S(10)
+    assert minimum(exp(x), x, Interval(-2, oo)) == exp(-2)
+    assert minimum(log(x) - x, x, S.Reals) is -oo
+    assert minimum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.NegativeOne
+    assert minimum(cos(x)-sin(x), x, S.Reals) == -sqrt(2)
+    assert minimum(y, x, S.Reals) == y
+    assert minimum(x/sqrt(x**2+1), x, S.Reals) == -1
+
+    raises(ValueError, lambda : minimum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), sin(x)))
+    raises(ValueError, lambda : minimum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), S.One))
+
+
+def test_issue_19869():
+    assert (maximum(sqrt(3)*(x - 1)/(3*sqrt(x**2 + 1)), x)
+        ) == sqrt(3)/3
+
+
+def test_issue_16469():
+    f = abs(a)
+    assert function_range(f, a, S.Reals) == Interval(0, oo, False, True)
+
+
+@_both_exp_pow
+def test_issue_18747():
+    assert periodicity(exp(pi*I*(x/4 + S.Half/2)), x) == 8
+
+
+def test_issue_25942():
+    assert (acos(x) > pi/3).as_set() == Interval.Ropen(-1, S(1)/2)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/calculus/util.py

@@ -0,0 +1,895 @@
+from .accumulationbounds import AccumBounds, AccumulationBounds # noqa: F401
+from .singularities import singularities
+from sympy.core import Pow, S
+from sympy.core.function import diff, expand_mul, Function
+from sympy.core.kind import NumberKind
+from sympy.core.mod import Mod
+from sympy.core.numbers import equal_valued
+from sympy.core.relational import Relational
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.complexes import Abs, im, re
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.integers import frac
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    TrigonometricFunction, sin, cos, tan, cot, csc, sec,
+    asin, acos, acot, atan, asec, acsc)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+    sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.polys.polytools import degree, lcm_list
+from sympy.sets.sets import (Interval, Intersection, FiniteSet, Union,
+                             Complement)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.conditionset import ConditionSet
+from sympy.utilities import filldedent
+from sympy.utilities.iterables import iterable
+from sympy.matrices.dense import hessian
+
+
+def continuous_domain(f, symbol, domain):
+    """
+    Returns the domain on which the function expression f is continuous.
+
+    This function is limited by the ability to determine the various
+    singularities and discontinuities of the given function.
+    The result is either given as a union of intervals or constructed using
+    other set operations.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the intervals are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the continuity of the symbol has to be checked.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, tan, log, pi, sqrt
+    >>> from sympy.calculus.util import continuous_domain
+    >>> x = Symbol('x')
+    >>> continuous_domain(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> continuous_domain(tan(x), x, Interval(0, pi))
+    Union(Interval.Ropen(0, pi/2), Interval.Lopen(pi/2, pi))
+    >>> continuous_domain(sqrt(x - 2), x, Interval(-5, 5))
+    Interval(2, 5)
+    >>> continuous_domain(log(2*x - 1), x, S.Reals)
+    Interval.open(1/2, oo)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all intervals where the function is continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If the method to determine continuity of such a function
+        has not yet been developed.
+
+    """
+    from sympy.solvers.inequalities import solve_univariate_inequality
+
+    if not domain.is_subset(S.Reals):
+        raise NotImplementedError(filldedent('''
+            Domain must be a subset of S.Reals.
+            '''))
+    implemented = [Pow, exp, log, Abs, frac,
+                   sin, cos, tan, cot, sec, csc,
+                   asin, acos, atan, acot, asec, acsc,
+                   sinh, cosh, tanh, coth, sech, csch,
+                   asinh, acosh, atanh, acoth, asech, acsch]
+    used = [fct.func for fct in f.atoms(Function) if fct.has(symbol)]
+    if any(func not in implemented for func in used):
+        raise NotImplementedError(filldedent('''
+            Unable to determine the domain of the given function.
+            '''))
+
+    x = Symbol('x')
+    constraints = {
+        log: (x > 0,),
+        asin: (x >= -1, x <= 1),
+        acos: (x >= -1, x <= 1),
+        acosh: (x >= 1,),
+        atanh: (x > -1, x < 1),
+        asech: (x > 0, x <= 1)
+    }
+    constraints_union = {
+        asec: (x <= -1, x >= 1),
+        acsc: (x <= -1, x >= 1),
+        acoth: (x < -1, x > 1)
+    }
+
+    cont_domain = domain
+    for atom in f.atoms(Pow):
+        den = atom.exp.as_numer_denom()[1]
+        if atom.exp.is_rational and den.is_odd:
+            pass    # 0**negative handled by singularities()
+        else:
+            constraint = solve_univariate_inequality(atom.base >= 0,
+                                                        symbol).as_set()
+            cont_domain = Intersection(constraint, cont_domain)
+
+    for atom in f.atoms(Function):
+        if atom.func in constraints:
+            for c in constraints[atom.func]:
+                constraint_relational = c.subs(x, atom.args[0])
+                constraint_set = solve_univariate_inequality(
+                    constraint_relational, symbol).as_set()
+                cont_domain = Intersection(constraint_set, cont_domain)
+        elif atom.func in constraints_union:
+            constraint_set = S.EmptySet
+            for c in constraints_union[atom.func]:
+                constraint_relational = c.subs(x, atom.args[0])
+                constraint_set += solve_univariate_inequality(
+                    constraint_relational, symbol).as_set()
+            cont_domain = Intersection(constraint_set, cont_domain)
+        # XXX: the discontinuities below could be factored out in
+        # a new "discontinuities()".
+        elif atom.func == acot:
+            from sympy.solvers.solveset import solveset_real
+            # Sympy's acot() has a step discontinuity at 0. Since it's
+            # neither an essential singularity nor a pole, singularities()
+            # will not report it. But it's still relevant for determining
+            # the continuity of the function f.
+            cont_domain -= solveset_real(atom.args[0], symbol)
+            # Note that the above may introduce spurious discontinuities, e.g.
+            # for abs(acot(x)) at 0.
+        elif atom.func == frac:
+            from sympy.solvers.solveset import solveset_real
+            r = function_range(atom.args[0], symbol, domain)
+            r = Intersection(r, S.Integers)
+            if r.is_finite_set:
+                discont = S.EmptySet
+                for n in r:
+                    discont += solveset_real(atom.args[0]-n, symbol)
+            else:
+                discont = ConditionSet(
+                    symbol, S.Integers.contains(atom.args[0]), cont_domain)
+            cont_domain -= discont
+
+    return cont_domain - singularities(f, symbol, domain)
+
+
+def function_range(f, symbol, domain):
+    """
+    Finds the range of a function in a given domain.
+    This method is limited by the ability to determine the singularities and
+    determine limits.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the range of function is to be determined.
+    domain : :py:class:`~.Interval`
+        The domain under which the range of the function has to be found.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, exp, log, pi, sqrt, sin, tan
+    >>> from sympy.calculus.util import function_range
+    >>> x = Symbol('x')
+    >>> function_range(sin(x), x, Interval(0, 2*pi))
+    Interval(-1, 1)
+    >>> function_range(tan(x), x, Interval(-pi/2, pi/2))
+    Interval(-oo, oo)
+    >>> function_range(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> function_range(exp(x), x, S.Reals)
+    Interval.open(0, oo)
+    >>> function_range(log(x), x, S.Reals)
+    Interval(-oo, oo)
+    >>> function_range(sqrt(x), x, Interval(-5, 9))
+    Interval(0, 3)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all ranges for all intervals under domain where function is
+        continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If any of the intervals, in the given domain, for which function
+        is continuous are not finite or real,
+        OR if the critical points of the function on the domain cannot be found.
+    """
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    period = periodicity(f, symbol)
+    if period == S.Zero:
+        # the expression is constant wrt symbol
+        return FiniteSet(f.expand())
+
+    from sympy.series.limits import limit
+    from sympy.solvers.solveset import solveset
+
+    if period is not None:
+        if isinstance(domain, Interval):
+            if (domain.inf - domain.sup).is_infinite:
+                domain = Interval(0, period)
+        elif isinstance(domain, Union):
+            for sub_dom in domain.args:
+                if isinstance(sub_dom, Interval) and \
+                ((sub_dom.inf - sub_dom.sup).is_infinite):
+                    domain = Interval(0, period)
+
+    intervals = continuous_domain(f, symbol, domain)
+    range_int = S.EmptySet
+    if isinstance(intervals,(Interval, FiniteSet)):
+        interval_iter = (intervals,)
+    elif isinstance(intervals, Union):
+        interval_iter = intervals.args
+    else:
+        raise NotImplementedError("Unable to find range for the given domain.")
+
+    for interval in interval_iter:
+        if isinstance(interval, FiniteSet):
+            for singleton in interval:
+                if singleton in domain:
+                    range_int += FiniteSet(f.subs(symbol, singleton))
+        elif isinstance(interval, Interval):
+            vals = S.EmptySet
+            critical_values = S.EmptySet
+            bounds = ((interval.left_open, interval.inf, '+'),
+                   (interval.right_open, interval.sup, '-'))
+
+            for is_open, limit_point, direction in bounds:
+                if is_open:
+                    critical_values += FiniteSet(limit(f, symbol, limit_point, direction))
+                    vals += critical_values
+                else:
+                    vals += FiniteSet(f.subs(symbol, limit_point))
+
+            critical_points = solveset(f.diff(symbol), symbol, interval)
+
+            if not iterable(critical_points):
+                raise NotImplementedError(
+                        'Unable to find critical points for {}'.format(f))
+            if isinstance(critical_points, ImageSet):
+                raise NotImplementedError(
+                        'Infinite number of critical points for {}'.format(f))
+
+            for critical_point in critical_points:
+                vals += FiniteSet(f.subs(symbol, critical_point))
+
+            left_open, right_open = False, False
+
+            if critical_values is not S.EmptySet:
+                if critical_values.inf == vals.inf:
+                    left_open = True
+
+                if critical_values.sup == vals.sup:
+                    right_open = True
+
+            range_int += Interval(vals.inf, vals.sup, left_open, right_open)
+        else:
+            raise NotImplementedError("Unable to find range for the given domain.")
+
+    return range_int
+
+
+def not_empty_in(finset_intersection, *syms):
+    """
+    Finds the domain of the functions in ``finset_intersection`` in which the
+    ``finite_set`` is not-empty.
+
+    Parameters
+    ==========
+
+    finset_intersection : Intersection of FiniteSet
+        The unevaluated intersection of FiniteSet containing
+        real-valued functions with Union of Sets
+    syms : Tuple of symbols
+        Symbol for which domain is to be found
+
+    Raises
+    ======
+
+    NotImplementedError
+        The algorithms to find the non-emptiness of the given FiniteSet are
+        not yet implemented.
+    ValueError
+        The input is not valid.
+    RuntimeError
+        It is a bug, please report it to the github issue tracker
+        (https://github.com/sympy/sympy/issues).
+
+    Examples
+    ========
+
+    >>> from sympy import FiniteSet, Interval, not_empty_in, oo
+    >>> from sympy.abc import x
+    >>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x)
+    Interval(0, 2)
+    >>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x)
+    Union(Interval(1, 2), Interval(-sqrt(2), -1))
+    >>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x)
+    Union(Interval.Lopen(-2, -1), Interval(2, oo))
+    """
+
+    # TODO: handle piecewise defined functions
+    # TODO: handle transcendental functions
+    # TODO: handle multivariate functions
+    if len(syms) == 0:
+        raise ValueError("One or more symbols must be given in syms.")
+
+    if finset_intersection is S.EmptySet:
+        return S.EmptySet
+
+    if isinstance(finset_intersection, Union):
+        elm_in_sets = finset_intersection.args[0]
+        return Union(not_empty_in(finset_intersection.args[1], *syms),
+                     elm_in_sets)
+
+    if isinstance(finset_intersection, FiniteSet):
+        finite_set = finset_intersection
+        _sets = S.Reals
+    else:
+        finite_set = finset_intersection.args[1]
+        _sets = finset_intersection.args[0]
+
+    if not isinstance(finite_set, FiniteSet):
+        raise ValueError('A FiniteSet must be given, not %s: %s' %
+                         (type(finite_set), finite_set))
+
+    if len(syms) == 1:
+        symb = syms[0]
+    else:
+        raise NotImplementedError('more than one variables %s not handled' %
+                                  (syms,))
+
+    def elm_domain(expr, intrvl):
+        """ Finds the domain of an expression in any given interval """
+        from sympy.solvers.solveset import solveset
+
+        _start = intrvl.start
+        _end = intrvl.end
+        _singularities = solveset(expr.as_numer_denom()[1], symb,
+                                  domain=S.Reals)
+
+        if intrvl.right_open:
+            if _end is S.Infinity:
+                _domain1 = S.Reals
+            else:
+                _domain1 = solveset(expr < _end, symb, domain=S.Reals)
+        else:
+            _domain1 = solveset(expr <= _end, symb, domain=S.Reals)
+
+        if intrvl.left_open:
+            if _start is S.NegativeInfinity:
+                _domain2 = S.Reals
+            else:
+                _domain2 = solveset(expr > _start, symb, domain=S.Reals)
+        else:
+            _domain2 = solveset(expr >= _start, symb, domain=S.Reals)
+
+        # domain in the interval
+        expr_with_sing = Intersection(_domain1, _domain2)
+        expr_domain = Complement(expr_with_sing, _singularities)
+        return expr_domain
+
+    if isinstance(_sets, Interval):
+        return Union(*[elm_domain(element, _sets) for element in finite_set])
+
+    if isinstance(_sets, Union):
+        _domain = S.EmptySet
+        for intrvl in _sets.args:
+            _domain_element = Union(*[elm_domain(element, intrvl)
+                                      for element in finite_set])
+            _domain = Union(_domain, _domain_element)
+        return _domain
+
+
+def periodicity(f, symbol, check=False):
+    """
+    Tests the given function for periodicity in the given symbol.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the period is to be determined.
+    check : bool, optional
+        The flag to verify whether the value being returned is a period or not.
+
+    Returns
+    =======
+
+    period
+        The period of the function is returned.
+        ``None`` is returned when the function is aperiodic or has a complex period.
+        The value of $0$ is returned as the period of a constant function.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The value of the period computed cannot be verified.
+
+
+    Notes
+    =====
+
+    Currently, we do not support functions with a complex period.
+    The period of functions having complex periodic values such
+    as ``exp``, ``sinh`` is evaluated to ``None``.
+
+    The value returned might not be the "fundamental" period of the given
+    function i.e. it may not be the smallest periodic value of the function.
+
+    The verification of the period through the ``check`` flag is not reliable
+    due to internal simplification of the given expression. Hence, it is set
+    to ``False`` by default.
+
+    Examples
+    ========
+    >>> from sympy import periodicity, Symbol, sin, cos, tan, exp
+    >>> x = Symbol('x')
+    >>> f = sin(x) + sin(2*x) + sin(3*x)
+    >>> periodicity(f, x)
+    2*pi
+    >>> periodicity(sin(x)*cos(x), x)
+    pi
+    >>> periodicity(exp(tan(2*x) - 1), x)
+    pi/2
+    >>> periodicity(sin(4*x)**cos(2*x), x)
+    pi
+    >>> periodicity(exp(x), x)
+    """
+    if symbol.kind is not NumberKind:
+        raise NotImplementedError("Cannot use symbol of kind %s" % symbol.kind)
+    temp = Dummy('x', real=True)
+    f = f.subs(symbol, temp)
+    symbol = temp
+
+    def _check(orig_f, period):
+        '''Return the checked period or raise an error.'''
+        new_f = orig_f.subs(symbol, symbol + period)
+        if new_f.equals(orig_f):
+            return period
+        else:
+            raise NotImplementedError(filldedent('''
+                The period of the given function cannot be verified.
+                When `%s` was replaced with `%s + %s` in `%s`, the result
+                was `%s` which was not recognized as being the same as
+                the original function.
+                So either the period was wrong or the two forms were
+                not recognized as being equal.
+                Set check=False to obtain the value.''' %
+                (symbol, symbol, period, orig_f, new_f)))
+
+    orig_f = f
+    period = None
+
+    if isinstance(f, Relational):
+        f = f.lhs - f.rhs
+
+    f = f.simplify()
+
+    if symbol not in f.free_symbols:
+        return S.Zero
+
+    if isinstance(f, TrigonometricFunction):
+        try:
+            period = f.period(symbol)
+        except NotImplementedError:
+            pass
+
+    if isinstance(f, Abs):
+        arg = f.args[0]
+        if isinstance(arg, (sec, csc, cos)):
+            # all but tan and cot might have a
+            # a period that is half as large
+            # so recast as sin
+            arg = sin(arg.args[0])
+        period = periodicity(arg, symbol)
+        if period is not None and isinstance(arg, sin):
+            # the argument of Abs was a trigonometric other than
+            # cot or tan; test to see if the half-period
+            # is valid. Abs(arg) has behaviour equivalent to
+            # orig_f, so use that for test:
+            orig_f = Abs(arg)
+            try:
+                return _check(orig_f, period/2)
+            except NotImplementedError as err:
+                if check:
+                    raise NotImplementedError(err)
+            # else let new orig_f and period be
+            # checked below
+
+    if isinstance(f, exp) or (f.is_Pow and f.base == S.Exp1):
+        f = Pow(S.Exp1, expand_mul(f.exp))
+        if im(f) != 0:
+            period_real = periodicity(re(f), symbol)
+            period_imag = periodicity(im(f), symbol)
+            if period_real is not None and period_imag is not None:
+                period = lcim([period_real, period_imag])
+
+    if f.is_Pow and f.base != S.Exp1:
+        base, expo = f.args
+        base_has_sym = base.has(symbol)
+        expo_has_sym = expo.has(symbol)
+
+        if base_has_sym and not expo_has_sym:
+            period = periodicity(base, symbol)
+
+        elif expo_has_sym and not base_has_sym:
+            period = periodicity(expo, symbol)
+
+        else:
+            period = _periodicity(f.args, symbol)
+
+    elif f.is_Mul:
+        coeff, g = f.as_independent(symbol, as_Add=False)
+        if isinstance(g, TrigonometricFunction) or not equal_valued(coeff, 1):
+            period = periodicity(g, symbol)
+        else:
+            period = _periodicity(g.args, symbol)
+
+    elif f.is_Add:
+        k, g = f.as_independent(symbol)
+        if k is not S.Zero:
+            return periodicity(g, symbol)
+
+        period = _periodicity(g.args, symbol)
+
+    elif isinstance(f, Mod):
+        a, n = f.args
+
+        if a == symbol:
+            period = n
+        elif isinstance(a, TrigonometricFunction):
+            period = periodicity(a, symbol)
+        #check if 'f' is linear in 'symbol'
+        elif (a.is_polynomial(symbol) and degree(a, symbol) == 1 and
+            symbol not in n.free_symbols):
+                period = Abs(n / a.diff(symbol))
+
+    elif isinstance(f, Piecewise):
+        pass  # not handling Piecewise yet as the return type is not favorable
+
+    elif period is None:
+        from sympy.solvers.decompogen import compogen, decompogen
+        g_s = decompogen(f, symbol)
+        num_of_gs = len(g_s)
+        if num_of_gs > 1:
+            for index, g in enumerate(reversed(g_s)):
+                start_index = num_of_gs - 1 - index
+                g = compogen(g_s[start_index:], symbol)
+                if g not in (orig_f, f): # Fix for issue 12620
+                    period = periodicity(g, symbol)
+                    if period is not None:
+                        break
+
+    if period is not None:
+        if check:
+            return _check(orig_f, period)
+        return period
+
+    return None
+
+
+def _periodicity(args, symbol):
+    """
+    Helper for `periodicity` to find the period of a list of simpler
+    functions.
+    It uses the `lcim` method to find the least common period of
+    all the functions.
+
+    Parameters
+    ==========
+
+    args : Tuple of :py:class:`~.Symbol`
+        All the symbols present in a function.
+
+    symbol : :py:class:`~.Symbol`
+        The symbol over which the function is to be evaluated.
+
+    Returns
+    =======
+
+    period
+        The least common period of the function for all the symbols
+        of the function.
+        ``None`` if for at least one of the symbols the function is aperiodic.
+
+    """
+    periods = []
+    for f in args:
+        period = periodicity(f, symbol)
+        if period is None:
+            return None
+
+        if period is not S.Zero:
+            periods.append(period)
+
+    if len(periods) > 1:
+        return lcim(periods)
+
+    if periods:
+        return periods[0]
+
+
+def lcim(numbers):
+    """Returns the least common integral multiple of a list of numbers.
+
+    The numbers can be rational or irrational or a mixture of both.
+    `None` is returned for incommensurable numbers.
+
+    Parameters
+    ==========
+
+    numbers : list
+        Numbers (rational and/or irrational) for which lcim is to be found.
+
+    Returns
+    =======
+
+    number
+        lcim if it exists, otherwise ``None`` for incommensurable numbers.
+
+    Examples
+    ========
+
+    >>> from sympy.calculus.util import lcim
+    >>> from sympy import S, pi
+    >>> lcim([S(1)/2, S(3)/4, S(5)/6])
+    15/2
+    >>> lcim([2*pi, 3*pi, pi, pi/2])
+    6*pi
+    >>> lcim([S(1), 2*pi])
+    """
+    result = None
+    if all(num.is_irrational for num in numbers):
+        factorized_nums = [num.factor() for num in numbers]
+        factors_num = [num.as_coeff_Mul() for num in factorized_nums]
+        term = factors_num[0][1]
+        if all(factor == term for coeff, factor in factors_num):
+            common_term = term
+            coeffs = [coeff for coeff, factor in factors_num]
+            result = lcm_list(coeffs) * common_term
+
+    elif all(num.is_rational for num in numbers):
+        result = lcm_list(numbers)
+
+    else:
+        pass
+
+    return result
+
+def is_convex(f, *syms, domain=S.Reals):
+    r"""Determines the  convexity of the function passed in the argument.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    syms : Tuple of :py:class:`~.Symbol`
+        The variables with respect to which the convexity is to be determined.
+    domain : :py:class:`~.Interval`, optional
+        The domain over which the convexity of the function has to be checked.
+        If unspecified, S.Reals will be the default domain.
+
+    Returns
+    =======
+
+    bool
+        The method returns ``True`` if the function is convex otherwise it
+        returns ``False``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The check for the convexity of multivariate functions is not implemented yet.
+
+    Notes
+    =====
+
+    To determine concavity of a function pass `-f` as the concerned function.
+    To determine logarithmic convexity of a function pass `\log(f)` as
+    concerned function.
+    To determine logarithmic concavity of a function pass `-\log(f)` as
+    concerned function.
+
+    Currently, convexity check of multivariate functions is not handled.
+
+    Examples
+    ========
+
+    >>> from sympy import is_convex, symbols, exp, oo, Interval
+    >>> x = symbols('x')
+    >>> is_convex(exp(x), x)
+    True
+    >>> is_convex(x**3, x, domain = Interval(-1, oo))
+    False
+    >>> is_convex(1/x**2, x, domain=Interval.open(0, oo))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convex_function
+    .. [2] http://www.ifp.illinois.edu/~angelia/L3_convfunc.pdf
+    .. [3] https://en.wikipedia.org/wiki/Logarithmically_convex_function
+    .. [4] https://en.wikipedia.org/wiki/Logarithmically_concave_function
+    .. [5] https://en.wikipedia.org/wiki/Concave_function
+
+    """
+    if len(syms) > 1 :
+        return hessian(f, syms).is_positive_semidefinite
+    from sympy.solvers.inequalities import solve_univariate_inequality
+    f = _sympify(f)
+    var = syms[0]
+    if any(s in domain for s in singularities(f, var)):
+        return False
+    condition = f.diff(var, 2) < 0
+    if solve_univariate_inequality(condition, var, False, domain):
+        return False
+    return True
+
+
+def stationary_points(f, symbol, domain=S.Reals):
+    """
+    Returns the stationary points of a function (where derivative of the
+    function is 0) in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the stationary points are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the stationary points have to be checked.
+        If unspecified, ``S.Reals`` will be the default domain.
+
+    Returns
+    =======
+
+    Set
+        A set of stationary points for the function. If there are no
+        stationary point, an :py:class:`~.EmptySet` is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, pi, pprint, stationary_points
+    >>> x = Symbol('x')
+
+    >>> stationary_points(1/x, x, S.Reals)
+    EmptySet
+
+    >>> pprint(stationary_points(sin(x), x), use_unicode=False)
+              pi                              3*pi
+    {2*n*pi + -- | n in Integers} U {2*n*pi + ---- | n in Integers}
+              2                                2
+
+    >>> stationary_points(sin(x),x, Interval(0, 4*pi))
+    {pi/2, 3*pi/2, 5*pi/2, 7*pi/2}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    domain = continuous_domain(f, symbol, domain)
+    set = solveset(diff(f, symbol), symbol, domain)
+
+    return set
+
+
+def maximum(f, symbol, domain=S.Reals):
+    """
+    Returns the maximum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for maximum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the maximum have to be checked.
+        If unspecified, then the global maximum is returned.
+
+    Returns
+    =======
+
+    number
+        Maximum value of the function in given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, pi, maximum
+    >>> x = Symbol('x')
+
+    >>> f = -x**2 + 2*x + 5
+    >>> maximum(f, x, S.Reals)
+    6
+
+    >>> maximum(sin(x), x, Interval(-pi, pi/4))
+    sqrt(2)/2
+
+    >>> maximum(sin(x)*cos(x), x)
+    1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Maximum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).sup
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)
+
+
+def minimum(f, symbol, domain=S.Reals):
+    """
+    Returns the minimum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for minimum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the minimum have to be checked.
+        If unspecified, then the global minimum is returned.
+
+    Returns
+    =======
+
+    number
+        Minimum value of the function in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, minimum
+    >>> x = Symbol('x')
+
+    >>> f = x**2 + 2*x + 5
+    >>> minimum(f, x, S.Reals)
+    4
+
+    >>> minimum(sin(x), x, Interval(2, 3))
+    sin(3)
+
+    >>> minimum(sin(x)*cos(x), x)
+    -1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Minimum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).inf
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/categories/__init__.py

@@ -0,0 +1,33 @@
+"""
+Category Theory module.
+
+Provides some of the fundamental category-theory-related classes,
+including categories, morphisms, diagrams.  Functors are not
+implemented yet.
+
+The general reference work this module tries to follow is
+
+  [JoyOfCats] J. Adamek, H. Herrlich. G. E. Strecker: Abstract and
+              Concrete Categories. The Joy of Cats.
+
+The latest version of this book should be available for free download
+from
+
+   katmat.math.uni-bremen.de/acc/acc.pdf
+
+"""
+
+from .baseclasses import (Object, Morphism, IdentityMorphism,
+                         NamedMorphism, CompositeMorphism, Category,
+                         Diagram)
+
+from .diagram_drawing import (DiagramGrid, XypicDiagramDrawer,
+                             xypic_draw_diagram, preview_diagram)
+
+__all__ = [
+    'Object', 'Morphism', 'IdentityMorphism', 'NamedMorphism',
+    'CompositeMorphism', 'Category', 'Diagram',
+
+    'DiagramGrid', 'XypicDiagramDrawer', 'xypic_draw_diagram',
+    'preview_diagram',
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/categories/baseclasses.py

@@ -0,0 +1,978 @@
+from sympy.core import S, Basic, Dict, Symbol, Tuple, sympify
+from sympy.core.symbol import Str
+from sympy.sets import Set, FiniteSet, EmptySet
+from sympy.utilities.iterables import iterable
+
+
+class Class(Set):
+    r"""
+    The base class for any kind of class in the set-theoretic sense.
+
+    Explanation
+    ===========
+
+    In axiomatic set theories, everything is a class.  A class which
+    can be a member of another class is a set.  A class which is not a
+    member of another class is a proper class.  The class `\{1, 2\}`
+    is a set; the class of all sets is a proper class.
+
+    This class is essentially a synonym for :class:`sympy.core.Set`.
+    The goal of this class is to assure easier migration to the
+    eventual proper implementation of set theory.
+    """
+    is_proper = False
+
+
+class Object(Symbol):
+    """
+    The base class for any kind of object in an abstract category.
+
+    Explanation
+    ===========
+
+    While technically any instance of :class:`~.Basic` will do, this
+    class is the recommended way to create abstract objects in
+    abstract categories.
+    """
+
+
+class Morphism(Basic):
+    """
+    The base class for any morphism in an abstract category.
+
+    Explanation
+    ===========
+
+    In abstract categories, a morphism is an arrow between two
+    category objects.  The object where the arrow starts is called the
+    domain, while the object where the arrow ends is called the
+    codomain.
+
+    Two morphisms between the same pair of objects are considered to
+    be the same morphisms.  To distinguish between morphisms between
+    the same objects use :class:`NamedMorphism`.
+
+    It is prohibited to instantiate this class.  Use one of the
+    derived classes instead.
+
+    See Also
+    ========
+
+    IdentityMorphism, NamedMorphism, CompositeMorphism
+    """
+    def __new__(cls, domain, codomain):
+        raise(NotImplementedError(
+            "Cannot instantiate Morphism.  Use derived classes instead."))
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.domain
+        Object("A")
+
+        """
+        return self.args[0]
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.codomain
+        Object("B")
+
+        """
+        return self.args[1]
+
+    def compose(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The order of elements in the composition is the usual order,
+        i.e., to construct `g\circ f` use ``g.compose(f)``.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> g * f
+        CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g")))
+        >>> (g * f).domain
+        Object("A")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return CompositeMorphism(other, self)
+
+    def __mul__(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The semantics of this operation is given by the following
+        equation: ``g * f == g.compose(f)`` for composable morphisms
+        ``g`` and ``f``.
+
+        See Also
+        ========
+
+        compose
+        """
+        return self.compose(other)
+
+
+class IdentityMorphism(Morphism):
+    """
+    Represents an identity morphism.
+
+    Explanation
+    ===========
+
+    An identity morphism is a morphism with equal domain and codomain,
+    which acts as an identity with respect to composition.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, IdentityMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> id_A = IdentityMorphism(A)
+    >>> id_B = IdentityMorphism(B)
+    >>> f * id_A == f
+    True
+    >>> id_B * f == f
+    True
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain):
+        return Basic.__new__(cls, domain)
+
+    @property
+    def codomain(self):
+        return self.domain
+
+
+class NamedMorphism(Morphism):
+    """
+    Represents a morphism which has a name.
+
+    Explanation
+    ===========
+
+    Names are used to distinguish between morphisms which have the
+    same domain and codomain: two named morphisms are equal if they
+    have the same domains, codomains, and names.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> f
+    NamedMorphism(Object("A"), Object("B"), "f")
+    >>> f.name
+    'f'
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain, codomain, name):
+        if not name:
+            raise ValueError("Empty morphism names not allowed.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        return Basic.__new__(cls, domain, codomain, name)
+
+    @property
+    def name(self):
+        """
+        Returns the name of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.name
+        'f'
+
+        """
+        return self.args[2].name
+
+
+class CompositeMorphism(Morphism):
+    r"""
+    Represents a morphism which is a composition of other morphisms.
+
+    Explanation
+    ===========
+
+    Two composite morphisms are equal if the morphisms they were
+    obtained from (components) are the same and were listed in the
+    same order.
+
+    The arguments to the constructor for this class should be listed
+    in diagram order: to obtain the composition `g\circ f` from the
+    instances of :class:`Morphism` ``g`` and ``f`` use
+    ``CompositeMorphism(f, g)``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, CompositeMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> g * f
+    CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+    NamedMorphism(Object("B"), Object("C"), "g")))
+    >>> CompositeMorphism(f, g) == g * f
+    True
+
+    """
+    @staticmethod
+    def _add_morphism(t, morphism):
+        """
+        Intelligently adds ``morphism`` to tuple ``t``.
+
+        Explanation
+        ===========
+
+        If ``morphism`` is a composite morphism, its components are
+        added to the tuple.  If ``morphism`` is an identity, nothing
+        is added to the tuple.
+
+        No composability checks are performed.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            # ``morphism`` is a composite morphism; we have to
+            # denest its components.
+            return t + morphism.components
+        elif isinstance(morphism, IdentityMorphism):
+            # ``morphism`` is an identity.  Nothing happens.
+            return t
+        else:
+            return t + Tuple(morphism)
+
+    def __new__(cls, *components):
+        if components and not isinstance(components[0], Morphism):
+            # Maybe the user has explicitly supplied a list of
+            # morphisms.
+            return CompositeMorphism.__new__(cls, *components[0])
+
+        normalised_components = Tuple()
+
+        for current, following in zip(components, components[1:]):
+            if not isinstance(current, Morphism) or \
+                    not isinstance(following, Morphism):
+                raise TypeError("All components must be morphisms.")
+
+            if current.codomain != following.domain:
+                raise ValueError("Uncomposable morphisms.")
+
+            normalised_components = CompositeMorphism._add_morphism(
+                normalised_components, current)
+
+        # We haven't added the last morphism to the list of normalised
+        # components.  Add it now.
+        normalised_components = CompositeMorphism._add_morphism(
+            normalised_components, components[-1])
+
+        if not normalised_components:
+            # If ``normalised_components`` is empty, only identities
+            # were supplied.  Since they all were composable, they are
+            # all the same identities.
+            return components[0]
+        elif len(normalised_components) == 1:
+            # No sense to construct a whole CompositeMorphism.
+            return normalised_components[0]
+
+        return Basic.__new__(cls, normalised_components)
+
+    @property
+    def components(self):
+        """
+        Returns the components of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).components
+        (NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g"))
+
+        """
+        return self.args[0]
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of this composite morphism.
+
+        The domain of the composite morphism is the domain of its
+        first component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).domain
+        Object("A")
+
+        """
+        return self.components[0].domain
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of this composite morphism.
+
+        The codomain of the composite morphism is the codomain of its
+        last component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return self.components[-1].codomain
+
+    def flatten(self, new_name):
+        """
+        Forgets the composite structure of this morphism.
+
+        Explanation
+        ===========
+
+        If ``new_name`` is not empty, returns a :class:`NamedMorphism`
+        with the supplied name, otherwise returns a :class:`Morphism`.
+        In both cases the domain of the new morphism is the domain of
+        this composite morphism and the codomain of the new morphism
+        is the codomain of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).flatten("h")
+        NamedMorphism(Object("A"), Object("C"), "h")
+
+        """
+        return NamedMorphism(self.domain, self.codomain, new_name)
+
+
+class Category(Basic):
+    r"""
+    An (abstract) category.
+
+    Explanation
+    ===========
+
+    A category [JoyOfCats] is a quadruple `\mbox{K} = (O, \hom, id,
+    \circ)` consisting of
+
+    * a (set-theoretical) class `O`, whose members are called
+      `K`-objects,
+
+    * for each pair `(A, B)` of `K`-objects, a set `\hom(A, B)` whose
+      members are called `K`-morphisms from `A` to `B`,
+
+    * for a each `K`-object `A`, a morphism `id:A\rightarrow A`,
+      called the `K`-identity of `A`,
+
+    * a composition law `\circ` associating with every `K`-morphisms
+      `f:A\rightarrow B` and `g:B\rightarrow C` a `K`-morphism `g\circ
+      f:A\rightarrow C`, called the composite of `f` and `g`.
+
+    Composition is associative, `K`-identities are identities with
+    respect to composition, and the sets `\hom(A, B)` are pairwise
+    disjoint.
+
+    This class knows nothing about its objects and morphisms.
+    Concrete cases of (abstract) categories should be implemented as
+    classes derived from this one.
+
+    Certain instances of :class:`Diagram` can be asserted to be
+    commutative in a :class:`Category` by supplying the argument
+    ``commutative_diagrams`` in the constructor.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+    >>> from sympy import FiniteSet
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> K = Category("K", commutative_diagrams=[d])
+    >>> K.commutative_diagrams == FiniteSet(d)
+    True
+
+    See Also
+    ========
+
+    Diagram
+    """
+    def __new__(cls, name, objects=EmptySet, commutative_diagrams=EmptySet):
+        if not name:
+            raise ValueError("A Category cannot have an empty name.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        if not isinstance(objects, Class):
+            objects = Class(objects)
+
+        new_category = Basic.__new__(cls, name, objects,
+                                     FiniteSet(*commutative_diagrams))
+        return new_category
+
+    @property
+    def name(self):
+        """
+        Returns the name of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Category
+        >>> K = Category("K")
+        >>> K.name
+        'K'
+
+        """
+        return self.args[0].name
+
+    @property
+    def objects(self):
+        """
+        Returns the class of objects of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> K = Category("K", FiniteSet(A, B))
+        >>> K.objects
+        Class({Object("A"), Object("B")})
+
+        """
+        return self.args[1]
+
+    @property
+    def commutative_diagrams(self):
+        """
+        Returns the :class:`~.FiniteSet` of diagrams which are known to
+        be commutative in this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> K = Category("K", commutative_diagrams=[d])
+        >>> K.commutative_diagrams == FiniteSet(d)
+        True
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        raise NotImplementedError(
+            "hom-sets are not implemented in Category.")
+
+    def all_morphisms(self):
+        raise NotImplementedError(
+            "Obtaining the class of morphisms is not implemented in Category.")
+
+
+class Diagram(Basic):
+    r"""
+    Represents a diagram in a certain category.
+
+    Explanation
+    ===========
+
+    Informally, a diagram is a collection of objects of a category and
+    certain morphisms between them.  A diagram is still a monoid with
+    respect to morphism composition; i.e., identity morphisms, as well
+    as all composites of morphisms included in the diagram belong to
+    the diagram.  For a more formal approach to this notion see
+    [Pare1970].
+
+    The components of composite morphisms are also added to the
+    diagram.  No properties are assigned to such morphisms by default.
+
+    A commutative diagram is often accompanied by a statement of the
+    following kind: "if such morphisms with such properties exist,
+    then such morphisms which such properties exist and the diagram is
+    commutative".  To represent this, an instance of :class:`Diagram`
+    includes a collection of morphisms which are the premises and
+    another collection of conclusions.  ``premises`` and
+    ``conclusions`` associate morphisms belonging to the corresponding
+    categories with the :class:`~.FiniteSet`'s of their properties.
+
+    The set of properties of a composite morphism is the intersection
+    of the sets of properties of its components.  The domain and
+    codomain of a conclusion morphism should be among the domains and
+    codomains of the morphisms listed as the premises of a diagram.
+
+    No checks are carried out of whether the supplied object and
+    morphisms do belong to one and the same category.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy import pprint, default_sort_key
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> premises_keys = sorted(d.premises.keys(), key=default_sort_key)
+    >>> pprint(premises_keys, use_unicode=False)
+    [g*f:A-->C, id:A-->A, id:B-->B, id:C-->C, f:A-->B, g:B-->C]
+    >>> pprint(d.premises, use_unicode=False)
+    {g*f:A-->C: EmptySet, id:A-->A: EmptySet, id:B-->B: EmptySet,
+     id:C-->C: EmptySet, f:A-->B: EmptySet, g:B-->C: EmptySet}
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> pprint(d.conclusions,use_unicode=False)
+    {g*f:A-->C: {unique}}
+
+    References
+    ==========
+
+    [Pare1970] B. Pareigis: Categories and functors.  Academic Press, 1970.
+
+    """
+    @staticmethod
+    def _set_dict_union(dictionary, key, value):
+        """
+        If ``key`` is in ``dictionary``, set the new value of ``key``
+        to be the union between the old value and ``value``.
+        Otherwise, set the value of ``key`` to ``value.
+
+        Returns ``True`` if the key already was in the dictionary and
+        ``False`` otherwise.
+        """
+        if key in dictionary:
+            dictionary[key] = dictionary[key] | value
+            return True
+        else:
+            dictionary[key] = value
+            return False
+
+    @staticmethod
+    def _add_morphism_closure(morphisms, morphism, props, add_identities=True,
+                              recurse_composites=True):
+        """
+        Adds a morphism and its attributes to the supplied dictionary
+        ``morphisms``.  If ``add_identities`` is True, also adds the
+        identity morphisms for the domain and the codomain of
+        ``morphism``.
+        """
+        if not Diagram._set_dict_union(morphisms, morphism, props):
+            # We have just added a new morphism.
+
+            if isinstance(morphism, IdentityMorphism):
+                if props:
+                    # Properties for identity morphisms don't really
+                    # make sense, because very much is known about
+                    # identity morphisms already, so much that they
+                    # are trivial.  Having properties for identity
+                    # morphisms would only be confusing.
+                    raise ValueError(
+                        "Instances of IdentityMorphism cannot have properties.")
+                return
+
+            if add_identities:
+                empty = EmptySet
+
+                id_dom = IdentityMorphism(morphism.domain)
+                id_cod = IdentityMorphism(morphism.codomain)
+
+                Diagram._set_dict_union(morphisms, id_dom, empty)
+                Diagram._set_dict_union(morphisms, id_cod, empty)
+
+            for existing_morphism, existing_props in list(morphisms.items()):
+                new_props = existing_props & props
+                if morphism.domain == existing_morphism.codomain:
+                    left = morphism * existing_morphism
+                    Diagram._set_dict_union(morphisms, left, new_props)
+                if morphism.codomain == existing_morphism.domain:
+                    right = existing_morphism * morphism
+                    Diagram._set_dict_union(morphisms, right, new_props)
+
+            if isinstance(morphism, CompositeMorphism) and recurse_composites:
+                # This is a composite morphism, add its components as
+                # well.
+                empty = EmptySet
+                for component in morphism.components:
+                    Diagram._add_morphism_closure(morphisms, component, empty,
+                                                  add_identities)
+
+    def __new__(cls, *args):
+        """
+        Construct a new instance of Diagram.
+
+        Explanation
+        ===========
+
+        If no arguments are supplied, an empty diagram is created.
+
+        If at least an argument is supplied, ``args[0]`` is
+        interpreted as the premises of the diagram.  If ``args[0]`` is
+        a list, it is interpreted as a list of :class:`Morphism`'s, in
+        which each :class:`Morphism` has an empty set of properties.
+        If ``args[0]`` is a Python dictionary or a :class:`Dict`, it
+        is interpreted as a dictionary associating to some
+        :class:`Morphism`'s some properties.
+
+        If at least two arguments are supplied ``args[1]`` is
+        interpreted as the conclusions of the diagram.  The type of
+        ``args[1]`` is interpreted in exactly the same way as the type
+        of ``args[0]``.  If only one argument is supplied, the diagram
+        has no conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f]
+        {unique}
+
+        """
+        premises = {}
+        conclusions = {}
+
+        # Here we will keep track of the objects which appear in the
+        # premises.
+        objects = EmptySet
+
+        if len(args) >= 1:
+            # We've got some premises in the arguments.
+            premises_arg = args[0]
+
+            if isinstance(premises_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in premises_arg:
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(premises, morphism, empty)
+            elif isinstance(premises_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in premises_arg.items():
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(
+                        premises, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props))
+
+        if len(args) >= 2:
+            # We also have some conclusions.
+            conclusions_arg = args[1]
+
+            if isinstance(conclusions_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in conclusions_arg:
+                    # Check that no new objects appear in conclusions.
+                    if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                        (sympify(objects.contains(morphism.codomain)) is S.true)):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, empty, add_identities=False,
+                            recurse_composites=False)
+            elif isinstance(conclusions_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in conclusions_arg.items():
+                    # Check that no new objects appear in conclusions.
+                    if (morphism.domain in objects) and \
+                       (morphism.codomain in objects):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props),
+                            add_identities=False, recurse_composites=False)
+
+        return Basic.__new__(cls, Dict(premises), Dict(conclusions), objects)
+
+    @property
+    def premises(self):
+        """
+        Returns the premises of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> id_A = IdentityMorphism(A)
+        >>> id_B = IdentityMorphism(B)
+        >>> d = Diagram([f])
+        >>> print(pretty(d.premises, use_unicode=False))
+        {id:A-->A: EmptySet, id:B-->B: EmptySet, f:A-->B: EmptySet}
+
+        """
+        return self.args[0]
+
+    @property
+    def conclusions(self):
+        """
+        Returns the conclusions of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f] == FiniteSet("unique")
+        True
+
+        """
+        return self.args[1]
+
+    @property
+    def objects(self):
+        """
+        Returns the :class:`~.FiniteSet` of objects that appear in this
+        diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> d.objects
+        {Object("A"), Object("B"), Object("C")}
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        """
+        Returns a 2-tuple of sets of morphisms between objects ``A`` and
+        ``B``: one set of morphisms listed as premises, and the other set
+        of morphisms listed as conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> print(pretty(d.hom(A, C), use_unicode=False))
+        ({g*f:A-->C}, {g*f:A-->C})
+
+        See Also
+        ========
+        Object, Morphism
+        """
+        premises = EmptySet
+        conclusions = EmptySet
+
+        for morphism in self.premises.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                premises |= FiniteSet(morphism)
+        for morphism in self.conclusions.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                conclusions |= FiniteSet(morphism)
+
+        return (premises, conclusions)
+
+    def is_subdiagram(self, diagram):
+        """
+        Checks whether ``diagram`` is a subdiagram of ``self``.
+        Diagram `D'` is a subdiagram of `D` if all premises
+        (conclusions) of `D'` are contained in the premises
+        (conclusions) of `D`.  The morphisms contained
+        both in `D'` and `D` should have the same properties for `D'`
+        to be a subdiagram of `D`.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d1 = Diagram([f])
+        >>> d.is_subdiagram(d1)
+        True
+        >>> d1.is_subdiagram(d)
+        False
+        """
+        premises = all((m in self.premises) and
+                       (diagram.premises[m] == self.premises[m])
+                       for m in diagram.premises)
+        if not premises:
+            return False
+
+        conclusions = all((m in self.conclusions) and
+                          (diagram.conclusions[m] == self.conclusions[m])
+                          for m in diagram.conclusions)
+
+        # Premises is surely ``True`` here.
+        return conclusions
+
+    def subdiagram_from_objects(self, objects):
+        """
+        If ``objects`` is a subset of the objects of ``self``, returns
+        a diagram which has as premises all those premises of ``self``
+        which have a domains and codomains in ``objects``, likewise
+        for conclusions.  Properties are preserved.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {f: "unique", g*f: "veryunique"})
+        >>> d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+        >>> d1 == Diagram([f], {f: "unique"})
+        True
+        """
+        if not objects.is_subset(self.objects):
+            raise ValueError(
+                "Supplied objects should all belong to the diagram.")
+
+        new_premises = {}
+        for morphism, props in self.premises.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_premises[morphism] = props
+
+        new_conclusions = {}
+        for morphism, props in self.conclusions.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_conclusions[morphism] = props
+
+        return Diagram(new_premises, new_conclusions)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/categories/diagram_drawing.py

@@ -0,0 +1,2580 @@
+r"""
+This module contains the functionality to arrange the nodes of a
+diagram on an abstract grid, and then to produce a graphical
+representation of the grid.
+
+The currently supported back-ends are Xy-pic [Xypic].
+
+Layout Algorithm
+================
+
+This section provides an overview of the algorithms implemented in
+:class:`DiagramGrid` to lay out diagrams.
+
+The first step of the algorithm is the removal composite and identity
+morphisms which do not have properties in the supplied diagram.  The
+premises and conclusions of the diagram are then merged.
+
+The generic layout algorithm begins with the construction of the
+"skeleton" of the diagram.  The skeleton is an undirected graph which
+has the objects of the diagram as vertices and has an (undirected)
+edge between each pair of objects between which there exist morphisms.
+The direction of the morphisms does not matter at this stage.  The
+skeleton also includes an edge between each pair of vertices `A` and
+`C` such that there exists an object `B` which is connected via
+a morphism to `A`, and via a morphism to `C`.
+
+The skeleton constructed in this way has the property that every
+object is a vertex of a triangle formed by three edges of the
+skeleton.  This property lies at the base of the generic layout
+algorithm.
+
+After the skeleton has been constructed, the algorithm lists all
+triangles which can be formed.  Note that some triangles will not have
+all edges corresponding to morphisms which will actually be drawn.
+Triangles which have only one edge or less which will actually be
+drawn are immediately discarded.
+
+The list of triangles is sorted according to the number of edges which
+correspond to morphisms, then the triangle with the least number of such
+edges is selected.  One of such edges is picked and the corresponding
+objects are placed horizontally, on a grid.  This edge is recorded to
+be in the fringe.  The algorithm then finds a "welding" of a triangle
+to the fringe.  A welding is an edge in the fringe where a triangle
+could be attached.  If the algorithm succeeds in finding such a
+welding, it adds to the grid that vertex of the triangle which was not
+yet included in any edge in the fringe and records the two new edges in
+the fringe.  This process continues iteratively until all objects of
+the diagram has been placed or until no more weldings can be found.
+
+An edge is only removed from the fringe when a welding to this edge
+has been found, and there is no room around this edge to place
+another vertex.
+
+When no more weldings can be found, but there are still triangles
+left, the algorithm searches for a possibility of attaching one of the
+remaining triangles to the existing structure by a vertex.  If such a
+possibility is found, the corresponding edge of the found triangle is
+placed in the found space and the iterative process of welding
+triangles restarts.
+
+When logical groups are supplied, each of these groups is laid out
+independently.  Then a diagram is constructed in which groups are
+objects and any two logical groups between which there exist morphisms
+are connected via a morphism.  This diagram is laid out.  Finally,
+the grid which includes all objects of the initial diagram is
+constructed by replacing the cells which contain logical groups with
+the corresponding laid out grids, and by correspondingly expanding the
+rows and columns.
+
+The sequential layout algorithm begins by constructing the
+underlying undirected graph defined by the morphisms obtained after
+simplifying premises and conclusions and merging them (see above).
+The vertex with the minimal degree is then picked up and depth-first
+search is started from it.  All objects which are located at distance
+`n` from the root in the depth-first search tree, are positioned in
+the `n`-th column of the resulting grid.  The sequential layout will
+therefore attempt to lay the objects out along a line.
+
+References
+==========
+
+.. [Xypic] https://xy-pic.sourceforge.net/
+
+"""
+from sympy.categories import (CompositeMorphism, IdentityMorphism,
+                              NamedMorphism, Diagram)
+from sympy.core import Dict, Symbol, default_sort_key
+from sympy.printing.latex import latex
+from sympy.sets import FiniteSet
+from sympy.utilities.iterables import iterable
+from sympy.utilities.decorator import doctest_depends_on
+
+from itertools import chain
+
+
+__doctest_requires__ = {('preview_diagram',): 'pyglet'}
+
+
+class _GrowableGrid:
+    """
+    Holds a growable grid of objects.
+
+    Explanation
+    ===========
+
+    It is possible to append or prepend a row or a column to the grid
+    using the corresponding methods.  Prepending rows or columns has
+    the effect of changing the coordinates of the already existing
+    elements.
+
+    This class currently represents a naive implementation of the
+    functionality with little attempt at optimisation.
+    """
+    def __init__(self, width, height):
+        self._width = width
+        self._height = height
+
+        self._array = [[None for j in range(width)] for i in range(height)]
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def height(self):
+        return self._height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        return self._array[i][j]
+
+    def __setitem__(self, i_j, newvalue):
+        """
+        Sets the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        self._array[i][j] = newvalue
+
+    def append_row(self):
+        """
+        Appends an empty row to the grid.
+        """
+        self._height += 1
+        self._array.append([None for j in range(self._width)])
+
+    def append_column(self):
+        """
+        Appends an empty column to the grid.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].append(None)
+
+    def prepend_row(self):
+        """
+        Prepends the grid with an empty row.
+        """
+        self._height += 1
+        self._array.insert(0, [None for j in range(self._width)])
+
+    def prepend_column(self):
+        """
+        Prepends the grid with an empty column.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].insert(0, None)
+
+
+class DiagramGrid:
+    r"""
+    Constructs and holds the fitting of the diagram into a grid.
+
+    Explanation
+    ===========
+
+    The mission of this class is to analyse the structure of the
+    supplied diagram and to place its objects on a grid such that,
+    when the objects and the morphisms are actually drawn, the diagram
+    would be "readable", in the sense that there will not be many
+    intersections of moprhisms.  This class does not perform any
+    actual drawing.  It does strive nevertheless to offer sufficient
+    metadata to draw a diagram.
+
+    Consider the following simple diagram.
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> from sympy.categories import Diagram, DiagramGrid
+    >>> from sympy import pprint
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g])
+
+    The simplest way to have a diagram laid out is the following:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> (grid.width, grid.height)
+    (2, 2)
+    >>> pprint(grid)
+    A  B
+    <BLANKLINE>
+       C
+
+    Sometimes one sees the diagram as consisting of logical groups.
+    One can advise ``DiagramGrid`` as to such groups by employing the
+    ``groups`` keyword argument.
+
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+
+    Lay it out with generic layout:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B  D
+    <BLANKLINE>
+       C
+
+    Now, we can group the objects `A` and `D` to have them near one
+    another:
+
+    >>> grid = DiagramGrid(diagram, groups=[[A, D], B, C])
+    >>> pprint(grid)
+    B     C
+    <BLANKLINE>
+    A  D
+
+    Note how the positioning of the other objects changes.
+
+    Further indications can be supplied to the constructor of
+    :class:`DiagramGrid` using keyword arguments.  The currently
+    supported hints are explained in the following paragraphs.
+
+    :class:`DiagramGrid` does not automatically guess which layout
+    would suit the supplied diagram better.  Consider, for example,
+    the following linear diagram:
+
+    >>> E = Object("E")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(C, D, "h")
+    >>> i = NamedMorphism(D, E, "i")
+    >>> diagram = Diagram([f, g, h, i])
+
+    When laid out with the generic layout, it does not get to look
+    linear:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B
+    <BLANKLINE>
+       C  D
+    <BLANKLINE>
+          E
+
+    To get it laid out in a line, use ``layout="sequential"``:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential")
+    >>> pprint(grid)
+    A  B  C  D  E
+
+    One may sometimes need to transpose the resulting layout.  While
+    this can always be done by hand, :class:`DiagramGrid` provides a
+    hint for that purpose:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential", transpose=True)
+    >>> pprint(grid)
+    A
+    <BLANKLINE>
+    B
+    <BLANKLINE>
+    C
+    <BLANKLINE>
+    D
+    <BLANKLINE>
+    E
+
+    Separate hints can also be provided for each group.  For an
+    example, refer to ``tests/test_drawing.py``, and see the different
+    ways in which the five lemma [FiveLemma] can be laid out.
+
+    See Also
+    ========
+
+    Diagram
+
+    References
+    ==========
+
+    .. [FiveLemma] https://en.wikipedia.org/wiki/Five_lemma
+    """
+    @staticmethod
+    def _simplify_morphisms(morphisms):
+        """
+        Given a dictionary mapping morphisms to their properties,
+        returns a new dictionary in which there are no morphisms which
+        do not have properties, and which are compositions of other
+        morphisms included in the dictionary.  Identities are dropped
+        as well.
+        """
+        newmorphisms = {}
+        for morphism, props in morphisms.items():
+            if isinstance(morphism, CompositeMorphism) and not props:
+                continue
+            elif isinstance(morphism, IdentityMorphism):
+                continue
+            else:
+                newmorphisms[morphism] = props
+        return newmorphisms
+
+    @staticmethod
+    def _merge_premises_conclusions(premises, conclusions):
+        """
+        Given two dictionaries of morphisms and their properties,
+        produces a single dictionary which includes elements from both
+        dictionaries.  If a morphism has some properties in premises
+        and also in conclusions, the properties in conclusions take
+        priority.
+        """
+        return dict(chain(premises.items(), conclusions.items()))
+
+    @staticmethod
+    def _juxtapose_edges(edge1, edge2):
+        """
+        If ``edge1`` and ``edge2`` have precisely one common endpoint,
+        returns an edge which would form a triangle with ``edge1`` and
+        ``edge2``.
+
+        If ``edge1`` and ``edge2`` do not have a common endpoint,
+        returns ``None``.
+
+        If ``edge1`` and ``edge`` are the same edge, returns ``None``.
+        """
+        intersection = edge1 & edge2
+        if len(intersection) != 1:
+            # The edges either have no common points or are equal.
+            return None
+
+        # The edges have a common endpoint.  Extract the different
+        # endpoints and set up the new edge.
+        return (edge1 - intersection) | (edge2 - intersection)
+
+    @staticmethod
+    def _add_edge_append(dictionary, edge, elem):
+        """
+        If ``edge`` is not in ``dictionary``, adds ``edge`` to the
+        dictionary and sets its value to ``[elem]``.  Otherwise
+        appends ``elem`` to the value of existing entry.
+
+        Note that edges are undirected, thus `(A, B) = (B, A)`.
+        """
+        if edge in dictionary:
+            dictionary[edge].append(elem)
+        else:
+            dictionary[edge] = [elem]
+
+    @staticmethod
+    def _build_skeleton(morphisms):
+        """
+        Creates a dictionary which maps edges to corresponding
+        morphisms.  Thus for a morphism `f:A\rightarrow B`, the edge
+        `(A, B)` will be associated with `f`.  This function also adds
+        to the list those edges which are formed by juxtaposition of
+        two edges already in the list.  These new edges are not
+        associated with any morphism and are only added to assure that
+        the diagram can be decomposed into triangles.
+        """
+        edges = {}
+        # Create edges for morphisms.
+        for morphism in morphisms:
+            DiagramGrid._add_edge_append(
+                edges, frozenset([morphism.domain, morphism.codomain]), morphism)
+
+        # Create new edges by juxtaposing existing edges.
+        edges1 = dict(edges)
+        for w in edges1:
+            for v in edges1:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv not in edges:
+                    edges[wv] = []
+
+        return edges
+
+    @staticmethod
+    def _list_triangles(edges):
+        """
+        Builds the set of triangles formed by the supplied edges.  The
+        triangles are arbitrary and need not be commutative.  A
+        triangle is a set that contains all three of its sides.
+        """
+        triangles = set()
+
+        for w in edges:
+            for v in edges:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv in edges:
+                    triangles.add(frozenset([w, v, wv]))
+
+        return triangles
+
+    @staticmethod
+    def _drop_redundant_triangles(triangles, skeleton):
+        """
+        Returns a list which contains only those triangles who have
+        morphisms associated with at least two edges.
+        """
+        return [tri for tri in triangles
+                if len([e for e in tri if skeleton[e]]) >= 2]
+
+    @staticmethod
+    def _morphism_length(morphism):
+        """
+        Returns the length of a morphism.  The length of a morphism is
+        the number of components it consists of.  A non-composite
+        morphism is of length 1.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            return len(morphism.components)
+        else:
+            return 1
+
+    @staticmethod
+    def _compute_triangle_min_sizes(triangles, edges):
+        r"""
+        Returns a dictionary mapping triangles to their minimal sizes.
+        The minimal size of a triangle is the sum of maximal lengths
+        of morphisms associated to the sides of the triangle.  The
+        length of a morphism is the number of components it consists
+        of.  A non-composite morphism is of length 1.
+
+        Sorting triangles by this metric attempts to address two
+        aspects of layout.  For triangles with only simple morphisms
+        in the edge, this assures that triangles with all three edges
+        visible will get typeset after triangles with less visible
+        edges, which sometimes minimizes the necessity in diagonal
+        arrows.  For triangles with composite morphisms in the edges,
+        this assures that objects connected with shorter morphisms
+        will be laid out first, resulting the visual proximity of
+        those objects which are connected by shorter morphisms.
+        """
+        triangle_sizes = {}
+        for triangle in triangles:
+            size = 0
+            for e in triangle:
+                morphisms = edges[e]
+                if morphisms:
+                    size += max(DiagramGrid._morphism_length(m)
+                                for m in morphisms)
+            triangle_sizes[triangle] = size
+        return triangle_sizes
+
+    @staticmethod
+    def _triangle_objects(triangle):
+        """
+        Given a triangle, returns the objects included in it.
+        """
+        # A triangle is a frozenset of three two-element frozensets
+        # (the edges).  This chains the three edges together and
+        # creates a frozenset from the iterator, thus producing a
+        # frozenset of objects of the triangle.
+        return frozenset(chain(*tuple(triangle)))
+
+    @staticmethod
+    def _other_vertex(triangle, edge):
+        """
+        Given a triangle and an edge of it, returns the vertex which
+        opposes the edge.
+        """
+        # This gets the set of objects of the triangle and then
+        # subtracts the set of objects employed in ``edge`` to get the
+        # vertex opposite to ``edge``.
+        return list(DiagramGrid._triangle_objects(triangle) - set(edge))[0]
+
+    @staticmethod
+    def _empty_point(pt, grid):
+        """
+        Checks if the cell at coordinates ``pt`` is either empty or
+        out of the bounds of the grid.
+        """
+        if (pt[0] < 0) or (pt[1] < 0) or \
+           (pt[0] >= grid.height) or (pt[1] >= grid.width):
+            return True
+        return grid[pt] is None
+
+    @staticmethod
+    def _put_object(coords, obj, grid, fringe):
+        """
+        Places an object at the coordinate ``cords`` in ``grid``,
+        growing the grid and updating ``fringe``, if necessary.
+        Returns (0, 0) if no row or column has been prepended, (1, 0)
+        if a row was prepended, (0, 1) if a column was prepended and
+        (1, 1) if both a column and a row were prepended.
+        """
+        (i, j) = coords
+        offset = (0, 0)
+        if i == -1:
+            grid.prepend_row()
+            i = 0
+            offset = (1, 0)
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1 + 1, j1), (i2 + 1, j2))
+        elif i == grid.height:
+            grid.append_row()
+
+        if j == -1:
+            j = 0
+            offset = (offset[0], 1)
+            grid.prepend_column()
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1, j1 + 1), (i2, j2 + 1))
+        elif j == grid.width:
+            grid.append_column()
+
+        grid[i, j] = obj
+        return offset
+
+    @staticmethod
+    def _choose_target_cell(pt1, pt2, edge, obj, skeleton, grid):
+        """
+        Given two points, ``pt1`` and ``pt2``, and the welding edge
+        ``edge``, chooses one of the two points to place the opposing
+        vertex ``obj`` of the triangle.  If neither of this points
+        fits, returns ``None``.
+        """
+        pt1_empty = DiagramGrid._empty_point(pt1, grid)
+        pt2_empty = DiagramGrid._empty_point(pt2, grid)
+
+        if pt1_empty and pt2_empty:
+            # Both cells are empty.  Of these two, choose that cell
+            # which will assure that a visible edge of the triangle
+            # will be drawn perpendicularly to the current welding
+            # edge.
+
+            A = grid[edge[0]]
+
+            if skeleton.get(frozenset([A, obj])):
+                return pt1
+            else:
+                return pt2
+        if pt1_empty:
+            return pt1
+        elif pt2_empty:
+            return pt2
+        else:
+            return None
+
+    @staticmethod
+    def _find_triangle_to_weld(triangles, fringe, grid):
+        """
+        Finds, if possible, a triangle and an edge in the ``fringe`` to
+        which the triangle could be attached.  Returns the tuple
+        containing the triangle and the index of the corresponding
+        edge in the ``fringe``.
+
+        This function relies on the fact that objects are unique in
+        the diagram.
+        """
+        for triangle in triangles:
+            for (a, b) in fringe:
+                if frozenset([grid[a], grid[b]]) in triangle:
+                    return (triangle, (a, b))
+        return None
+
+    @staticmethod
+    def _weld_triangle(tri, welding_edge, fringe, grid, skeleton):
+        """
+        If possible, welds the triangle ``tri`` to ``fringe`` and
+        returns ``False``.  If this method encounters a degenerate
+        situation in the fringe and corrects it such that a restart of
+        the search is required, it returns ``True`` (which means that
+        a restart in finding triangle weldings is required).
+
+        A degenerate situation is a situation when an edge listed in
+        the fringe does not belong to the visual boundary of the
+        diagram.
+        """
+        a, b = welding_edge
+        target_cell = None
+
+        obj = DiagramGrid._other_vertex(tri, (grid[a], grid[b]))
+
+        # We now have a triangle and an edge where it can be welded to
+        # the fringe.  Decide where to place the other vertex of the
+        # triangle and check for degenerate situations en route.
+
+        if (abs(a[0] - b[0]) == 1) and (abs(a[1] - b[1]) == 1):
+            # A diagonal edge.
+            target_cell = (a[0], b[1])
+            if grid[target_cell]:
+                # That cell is already occupied.
+                target_cell = (b[0], a[1])
+
+                if grid[target_cell]:
+                    # Degenerate situation, this edge is not
+                    # on the actual fringe.  Correct the
+                    # fringe and go on.
+                    fringe.remove((a, b))
+                    return True
+        elif a[0] == b[0]:
+            # A horizontal edge.  We first attempt to build the
+            # triangle in the downward direction.
+
+            down_left = a[0] + 1, a[1]
+            down_right = a[0] + 1, b[1]
+
+            target_cell = DiagramGrid._choose_target_cell(
+                down_left, down_right, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room below this edge.  Check above.
+                up_left = a[0] - 1, a[1]
+                up_right = a[0] - 1, b[1]
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    up_left, up_right, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+        elif a[1] == b[1]:
+            # A vertical edge.  We will attempt to place the other
+            # vertex of the triangle to the right of this edge.
+            right_up = a[0], a[1] + 1
+            right_down = b[0], a[1] + 1
+
+            target_cell = DiagramGrid._choose_target_cell(
+                right_up, right_down, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room to the left.  See what's to the right.
+                left_up = a[0], a[1] - 1
+                left_down = b[0], a[1] - 1
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    left_up, left_down, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+
+        # We now know where to place the other vertex of the
+        # triangle.
+        offset = DiagramGrid._put_object(target_cell, obj, grid, fringe)
+
+        # Take care of the displacement of coordinates if a row or
+        # a column was prepended.
+        target_cell = (target_cell[0] + offset[0],
+                       target_cell[1] + offset[1])
+        a = (a[0] + offset[0], a[1] + offset[1])
+        b = (b[0] + offset[0], b[1] + offset[1])
+
+        fringe.extend([(a, target_cell), (b, target_cell)])
+
+        # No restart is required.
+        return False
+
+    @staticmethod
+    def _triangle_key(tri, triangle_sizes):
+        """
+        Returns a key for the supplied triangle.  It should be the
+        same independently of the hash randomisation.
+        """
+        objects = sorted(
+            DiagramGrid._triangle_objects(tri), key=default_sort_key)
+        return (triangle_sizes[tri], default_sort_key(objects))
+
+    @staticmethod
+    def _pick_root_edge(tri, skeleton):
+        """
+        For a given triangle always picks the same root edge.  The
+        root edge is the edge that will be placed first on the grid.
+        """
+        candidates = [sorted(e, key=default_sort_key)
+                      for e in tri if skeleton[e]]
+        sorted_candidates = sorted(candidates, key=default_sort_key)
+        # Don't forget to assure the proper ordering of the vertices
+        # in this edge.
+        return tuple(sorted(sorted_candidates[0], key=default_sort_key))
+
+    @staticmethod
+    def _drop_irrelevant_triangles(triangles, placed_objects):
+        """
+        Returns only those triangles whose set of objects is not
+        completely included in ``placed_objects``.
+        """
+        return [tri for tri in triangles if not placed_objects.issuperset(
+            DiagramGrid._triangle_objects(tri))]
+
+    @staticmethod
+    def _grow_pseudopod(triangles, fringe, grid, skeleton, placed_objects):
+        """
+        Starting from an object in the existing structure on the ``grid``,
+        adds an edge to which a triangle from ``triangles`` could be
+        welded.  If this method has found a way to do so, it returns
+        the object it has just added.
+
+        This method should be applied when ``_weld_triangle`` cannot
+        find weldings any more.
+        """
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if not obj:
+                    continue
+
+                # Here we need to choose a triangle which has only
+                # ``obj`` in common with the existing structure.  The
+                # situations when this is not possible should be
+                # handled elsewhere.
+
+                def good_triangle(tri):
+                    objs = DiagramGrid._triangle_objects(tri)
+                    return obj in objs and \
+                        placed_objects & (objs - {obj}) == set()
+
+                tris = [tri for tri in triangles if good_triangle(tri)]
+                if not tris:
+                    # This object is not interesting.
+                    continue
+
+                # Pick the "simplest" of the triangles which could be
+                # attached.  Remember that the list of triangles is
+                # sorted according to their "simplicity" (see
+                # _compute_triangle_min_sizes for the metric).
+                #
+                # Note that ``tris`` are sequentially built from
+                # ``triangles``, so we don't have to worry about hash
+                # randomisation.
+                tri = tris[0]
+
+                # We have found a triangle which could be attached to
+                # the existing structure by a vertex.
+
+                candidates = sorted([e for e in tri if skeleton[e]],
+                                    key=lambda e: FiniteSet(*e).sort_key())
+                edges = [e for e in candidates if obj in e]
+
+                # Note that a meaningful edge (i.e., and edge that is
+                # associated with a morphism) containing ``obj``
+                # always exists.  That's because all triangles are
+                # guaranteed to have at least two meaningful edges.
+                # See _drop_redundant_triangles.
+
+                # Get the object at the other end of the edge.
+                edge = edges[0]
+                other_obj = tuple(edge - frozenset([obj]))[0]
+
+                # Now check for free directions.  When checking for
+                # free directions, prefer the horizontal and vertical
+                # directions.
+                neighbours = [(i - 1, j), (i, j + 1), (i + 1, j), (i, j - 1),
+                              (i - 1, j - 1), (i - 1, j + 1), (i + 1, j - 1), (i + 1, j + 1)]
+
+                for pt in neighbours:
+                    if DiagramGrid._empty_point(pt, grid):
+                        # We have a found a place to grow the
+                        # pseudopod into.
+                        offset = DiagramGrid._put_object(
+                            pt, other_obj, grid, fringe)
+
+                        i += offset[0]
+                        j += offset[1]
+                        pt = (pt[0] + offset[0], pt[1] + offset[1])
+                        fringe.append(((i, j), pt))
+
+                        return other_obj
+
+        # This diagram is actually cooler that I can handle.  Fail cowardly.
+        return None
+
+    @staticmethod
+    def _handle_groups(diagram, groups, merged_morphisms, hints):
+        """
+        Given the slightly preprocessed morphisms of the diagram,
+        produces a grid laid out according to ``groups``.
+
+        If a group has hints, it is laid out with those hints only,
+        without any influence from ``hints``.  Otherwise, it is laid
+        out with ``hints``.
+        """
+        def lay_out_group(group, local_hints):
+            """
+            If ``group`` is a set of objects, uses a ``DiagramGrid``
+            to lay it out and returns the grid.  Otherwise returns the
+            object (i.e., ``group``).  If ``local_hints`` is not
+            empty, it is supplied to ``DiagramGrid`` as the dictionary
+            of hints.  Otherwise, the ``hints`` argument of
+            ``_handle_groups`` is used.
+            """
+            if isinstance(group, FiniteSet):
+                # Set up the corresponding object-to-group
+                # mappings.
+                for obj in group:
+                    obj_groups[obj] = group
+
+                # Lay out the current group.
+                if local_hints:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **local_hints)
+                else:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **hints)
+            else:
+                obj_groups[group] = group
+
+        def group_to_finiteset(group):
+            """
+            Converts ``group`` to a :class:``FiniteSet`` if it is an
+            iterable.
+            """
+            if iterable(group):
+                return FiniteSet(*group)
+            else:
+                return group
+
+        obj_groups = {}
+        groups_grids = {}
+
+        # We would like to support various containers to represent
+        # groups.  To achieve that, before laying each group out, it
+        # should be converted to a FiniteSet, because that is what the
+        # following code expects.
+
+        if isinstance(groups, (dict, Dict)):
+            finiteset_groups = {}
+            for group, local_hints in groups.items():
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups[finiteset_group] = local_hints
+                lay_out_group(group, local_hints)
+            groups = finiteset_groups
+        else:
+            finiteset_groups = []
+            for group in groups:
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups.append(finiteset_group)
+                lay_out_group(finiteset_group, None)
+            groups = finiteset_groups
+
+        new_morphisms = []
+        for morphism in merged_morphisms:
+            dom = obj_groups[morphism.domain]
+            cod = obj_groups[morphism.codomain]
+            # Note that we are not really interested in morphisms
+            # which do not employ two different groups, because
+            # these do not influence the layout.
+            if dom != cod:
+                # These are essentially unnamed morphisms; they are
+                # not going to mess in the final layout.  By giving
+                # them the same names, we avoid unnecessary
+                # duplicates.
+                new_morphisms.append(NamedMorphism(dom, cod, "dummy"))
+
+        # Lay out the new diagram.  Since these are dummy morphisms,
+        # properties and conclusions are irrelevant.
+        top_grid = DiagramGrid(Diagram(new_morphisms))
+
+        # We now have to substitute the groups with the corresponding
+        # grids, laid out at the beginning of this function.  Compute
+        # the size of each row and column in the grid, so that all
+        # nested grids fit.
+
+        def group_size(group):
+            """
+            For the supplied group (or object, eventually), returns
+            the size of the cell that will hold this group (object).
+            """
+            if group in groups_grids:
+                grid = groups_grids[group]
+                return (grid.height, grid.width)
+            else:
+                return (1, 1)
+
+        row_heights = [max(group_size(top_grid[i, j])[0]
+                           for j in range(top_grid.width))
+                       for i in range(top_grid.height)]
+
+        column_widths = [max(group_size(top_grid[i, j])[1]
+                             for i in range(top_grid.height))
+                         for j in range(top_grid.width)]
+
+        grid = _GrowableGrid(sum(column_widths), sum(row_heights))
+
+        real_row = 0
+        real_column = 0
+        for logical_row in range(top_grid.height):
+            for logical_column in range(top_grid.width):
+                obj = top_grid[logical_row, logical_column]
+
+                if obj in groups_grids:
+                    # This is a group.  Copy the corresponding grid in
+                    # place.
+                    local_grid = groups_grids[obj]
+                    for i in range(local_grid.height):
+                        for j in range(local_grid.width):
+                            grid[real_row + i,
+                                real_column + j] = local_grid[i, j]
+                else:
+                    # This is an object.  Just put it there.
+                    grid[real_row, real_column] = obj
+
+                real_column += column_widths[logical_column]
+            real_column = 0
+            real_row += row_heights[logical_row]
+
+        return grid
+
+    @staticmethod
+    def _generic_layout(diagram, merged_morphisms):
+        """
+        Produces the generic layout for the supplied diagram.
+        """
+        all_objects = set(diagram.objects)
+        if len(all_objects) == 1:
+            # There only one object in the diagram, just put in on 1x1
+            # grid.
+            grid = _GrowableGrid(1, 1)
+            grid[0, 0] = tuple(all_objects)[0]
+            return grid
+
+        skeleton = DiagramGrid._build_skeleton(merged_morphisms)
+
+        grid = _GrowableGrid(2, 1)
+
+        if len(skeleton) == 1:
+            # This diagram contains only one morphism.  Draw it
+            # horizontally.
+            objects = sorted(all_objects, key=default_sort_key)
+            grid[0, 0] = objects[0]
+            grid[0, 1] = objects[1]
+
+            return grid
+
+        triangles = DiagramGrid._list_triangles(skeleton)
+        triangles = DiagramGrid._drop_redundant_triangles(triangles, skeleton)
+        triangle_sizes = DiagramGrid._compute_triangle_min_sizes(
+            triangles, skeleton)
+
+        triangles = sorted(triangles, key=lambda tri:
+                           DiagramGrid._triangle_key(tri, triangle_sizes))
+
+        # Place the first edge on the grid.
+        root_edge = DiagramGrid._pick_root_edge(triangles[0], skeleton)
+        grid[0, 0], grid[0, 1] = root_edge
+        fringe = [((0, 0), (0, 1))]
+
+        # Record which objects we now have on the grid.
+        placed_objects = set(root_edge)
+
+        while placed_objects != all_objects:
+            welding = DiagramGrid._find_triangle_to_weld(
+                triangles, fringe, grid)
+
+            if welding:
+                (triangle, welding_edge) = welding
+
+                restart_required = DiagramGrid._weld_triangle(
+                    triangle, welding_edge, fringe, grid, skeleton)
+                if restart_required:
+                    continue
+
+                placed_objects.update(
+                    DiagramGrid._triangle_objects(triangle))
+            else:
+                # No more weldings found.  Try to attach triangles by
+                # vertices.
+                new_obj = DiagramGrid._grow_pseudopod(
+                    triangles, fringe, grid, skeleton, placed_objects)
+
+                if not new_obj:
+                    # No more triangles can be attached, not even by
+                    # the edge.  We will set up a new diagram out of
+                    # what has been left, laid it out independently,
+                    # and then attach it to this one.
+
+                    remaining_objects = all_objects - placed_objects
+
+                    remaining_diagram = diagram.subdiagram_from_objects(
+                        FiniteSet(*remaining_objects))
+                    remaining_grid = DiagramGrid(remaining_diagram)
+
+                    # Now, let's glue ``remaining_grid`` to ``grid``.
+                    final_width = grid.width + remaining_grid.width
+                    final_height = max(grid.height, remaining_grid.height)
+                    final_grid = _GrowableGrid(final_width, final_height)
+
+                    for i in range(grid.width):
+                        for j in range(grid.height):
+                            final_grid[i, j] = grid[i, j]
+
+                    start_j = grid.width
+                    for i in range(remaining_grid.height):
+                        for j in range(remaining_grid.width):
+                            final_grid[i, start_j + j] = remaining_grid[i, j]
+
+                    return final_grid
+
+                placed_objects.add(new_obj)
+
+            triangles = DiagramGrid._drop_irrelevant_triangles(
+                triangles, placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _get_undirected_graph(objects, merged_morphisms):
+        """
+        Given the objects and the relevant morphisms of a diagram,
+        returns the adjacency lists of the underlying undirected
+        graph.
+        """
+        adjlists = {obj: [] for obj in objects}
+
+        for morphism in merged_morphisms:
+            adjlists[morphism.domain].append(morphism.codomain)
+            adjlists[morphism.codomain].append(morphism.domain)
+
+        # Assure that the objects in the adjacency list are always in
+        # the same order.
+        for obj in adjlists.keys():
+            adjlists[obj].sort(key=default_sort_key)
+
+        return adjlists
+
+    @staticmethod
+    def _sequential_layout(diagram, merged_morphisms):
+        r"""
+        Lays out the diagram in "sequential" layout.  This method
+        will attempt to produce a result as close to a line as
+        possible.  For linear diagrams, the result will actually be a
+        line.
+        """
+        objects = diagram.objects
+        sorted_objects = sorted(objects, key=default_sort_key)
+
+        # Set up the adjacency lists of the underlying undirected
+        # graph of ``merged_morphisms``.
+        adjlists = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        root = min(sorted_objects, key=lambda x: len(adjlists[x]))
+        grid = _GrowableGrid(1, 1)
+        grid[0, 0] = root
+
+        placed_objects = {root}
+
+        def place_objects(pt, placed_objects):
+            """
+            Does depth-first search in the underlying graph of the
+            diagram and places the objects en route.
+            """
+            # We will start placing new objects from here.
+            new_pt = (pt[0], pt[1] + 1)
+
+            for adjacent_obj in adjlists[grid[pt]]:
+                if adjacent_obj in placed_objects:
+                    # This object has already been placed.
+                    continue
+
+                DiagramGrid._put_object(new_pt, adjacent_obj, grid, [])
+                placed_objects.add(adjacent_obj)
+                placed_objects.update(place_objects(new_pt, placed_objects))
+
+                new_pt = (new_pt[0] + 1, new_pt[1])
+
+            return placed_objects
+
+        place_objects((0, 0), placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _drop_inessential_morphisms(merged_morphisms):
+        r"""
+        Removes those morphisms which should appear in the diagram,
+        but which have no relevance to object layout.
+
+        Currently this removes "loop" morphisms: the non-identity
+        morphisms with the same domains and codomains.
+        """
+        morphisms = [m for m in merged_morphisms if m.domain != m.codomain]
+        return morphisms
+
+    @staticmethod
+    def _get_connected_components(objects, merged_morphisms):
+        """
+        Given a container of morphisms, returns a list of connected
+        components formed by these morphisms.  A connected component
+        is represented by a diagram consisting of the corresponding
+        morphisms.
+        """
+        component_index = {}
+        for o in objects:
+            component_index[o] = None
+
+        # Get the underlying undirected graph of the diagram.
+        adjlist = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        def traverse_component(object, current_index):
+            """
+            Does a depth-first search traversal of the component
+            containing ``object``.
+            """
+            component_index[object] = current_index
+            for o in adjlist[object]:
+                if component_index[o] is None:
+                    traverse_component(o, current_index)
+
+        # Traverse all components.
+        current_index = 0
+        for o in adjlist:
+            if component_index[o] is None:
+                traverse_component(o, current_index)
+                current_index += 1
+
+        # List the objects of the components.
+        component_objects = [[] for i in range(current_index)]
+        for o, idx in component_index.items():
+            component_objects[idx].append(o)
+
+        # Finally, list the morphisms belonging to each component.
+        #
+        # Note: If some objects are isolated, they will not get any
+        # morphisms at this stage, and since the layout algorithm
+        # relies, we are essentially going to lose this object.
+        # Therefore, check if there are isolated objects and, for each
+        # of them, provide the trivial identity morphism.  It will get
+        # discarded later, but the object will be there.
+
+        component_morphisms = []
+        for component in component_objects:
+            current_morphisms = {}
+            for m in merged_morphisms:
+                if (m.domain in component) and (m.codomain in component):
+                    current_morphisms[m] = merged_morphisms[m]
+
+            if len(component) == 1:
+                # Let's add an identity morphism, for the sake of
+                # surely having morphisms in this component.
+                current_morphisms[IdentityMorphism(component[0])] = FiniteSet()
+
+            component_morphisms.append(Diagram(current_morphisms))
+
+        return component_morphisms
+
+    def __init__(self, diagram, groups=None, **hints):
+        premises = DiagramGrid._simplify_morphisms(diagram.premises)
+        conclusions = DiagramGrid._simplify_morphisms(diagram.conclusions)
+        all_merged_morphisms = DiagramGrid._merge_premises_conclusions(
+            premises, conclusions)
+        merged_morphisms = DiagramGrid._drop_inessential_morphisms(
+            all_merged_morphisms)
+
+        # Store the merged morphisms for later use.
+        self._morphisms = all_merged_morphisms
+
+        components = DiagramGrid._get_connected_components(
+            diagram.objects, all_merged_morphisms)
+
+        if groups and (groups != diagram.objects):
+            # Lay out the diagram according to the groups.
+            self._grid = DiagramGrid._handle_groups(
+                diagram, groups, merged_morphisms, hints)
+        elif len(components) > 1:
+            # Note that we check for connectedness _before_ checking
+            # the layout hints because the layout strategies don't
+            # know how to deal with disconnected diagrams.
+
+            # The diagram is disconnected.  Lay out the components
+            # independently.
+            grids = []
+
+            # Sort the components to eventually get the grids arranged
+            # in a fixed, hash-independent order.
+            components = sorted(components, key=default_sort_key)
+
+            for component in components:
+                grid = DiagramGrid(component, **hints)
+                grids.append(grid)
+
+            # Throw the grids together, in a line.
+            total_width = sum(g.width for g in grids)
+            total_height = max(g.height for g in grids)
+
+            grid = _GrowableGrid(total_width, total_height)
+            start_j = 0
+            for g in grids:
+                for i in range(g.height):
+                    for j in range(g.width):
+                        grid[i, start_j + j] = g[i, j]
+
+                start_j += g.width
+
+            self._grid = grid
+        elif "layout" in hints:
+            if hints["layout"] == "sequential":
+                self._grid = DiagramGrid._sequential_layout(
+                    diagram, merged_morphisms)
+        else:
+            self._grid = DiagramGrid._generic_layout(diagram, merged_morphisms)
+
+        if hints.get("transpose"):
+            # Transpose the resulting grid.
+            grid = _GrowableGrid(self._grid.height, self._grid.width)
+            for i in range(self._grid.height):
+                for j in range(self._grid.width):
+                    grid[j, i] = self._grid[i, j]
+            self._grid = grid
+
+    @property
+    def width(self):
+        """
+        Returns the number of columns in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.width
+        2
+
+        """
+        return self._grid.width
+
+    @property
+    def height(self):
+        """
+        Returns the number of rows in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.height
+        2
+
+        """
+        return self._grid.height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the object placed in the row ``i`` and column ``j``.
+        The indices are 0-based.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> (grid[0, 0], grid[0, 1])
+        (Object("A"), Object("B"))
+        >>> (grid[1, 0], grid[1, 1])
+        (None, Object("C"))
+
+        """
+        i, j = i_j
+        return self._grid[i, j]
+
+    @property
+    def morphisms(self):
+        """
+        Returns those morphisms (and their properties) which are
+        sufficiently meaningful to be drawn.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.morphisms
+        {NamedMorphism(Object("A"), Object("B"), "f"): EmptySet,
+        NamedMorphism(Object("B"), Object("C"), "g"): EmptySet}
+
+        """
+        return self._morphisms
+
+    def __str__(self):
+        """
+        Produces a string representation of this class.
+
+        This method returns a string representation of the underlying
+        list of lists of objects.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> print(grid)
+        [[Object("A"), Object("B")],
+        [None, Object("C")]]
+
+        """
+        return repr(self._grid._array)
+
+
+class ArrowStringDescription:
+    r"""
+    Stores the information necessary for producing an Xy-pic
+    description of an arrow.
+
+    The principal goal of this class is to abstract away the string
+    representation of an arrow and to also provide the functionality
+    to produce the actual Xy-pic string.
+
+    ``unit`` sets the unit which will be used to specify the amount of
+    curving and other distances.  ``horizontal_direction`` should be a
+    string of ``"r"`` or ``"l"`` specifying the horizontal offset of the
+    target cell of the arrow relatively to the current one.
+    ``vertical_direction`` should  specify the vertical offset using a
+    series of either ``"d"`` or ``"u"``.  ``label_position`` should be
+    either ``"^"``, ``"_"``,  or ``"|"`` to specify that the label should
+    be positioned above the arrow, below the arrow or just over the arrow,
+    in a break.  Note that the notions "above" and "below" are relative
+    to arrow direction.  ``label`` stores the morphism label.
+
+    This works as follows (disregard the yet unexplained arguments):
+
+    >>> from sympy.categories.diagram_drawing import ArrowStringDescription
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar[dr]_{f}
+
+    ``curving`` should be one of ``"^"``, ``"_"`` to specify in which
+    direction the arrow is going to curve. ``curving_amount`` is a number
+    describing how many ``unit``'s the morphism is going to curve:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_{f}
+
+    ``looping_start`` and ``looping_end`` are currently only used for
+    loop morphisms, those which have the same domain and codomain.
+    These two attributes should store a valid Xy-pic direction and
+    specify, correspondingly, the direction the arrow gets out into
+    and the direction the arrow gets back from:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start="u", looping_end="l", horizontal_direction="",
+    ... vertical_direction="", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@(u,l)[]_{f}
+
+    ``label_displacement`` controls how far the arrow label is from
+    the ends of the arrow.  For example, to position the arrow label
+    near the arrow head, use ">":
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.label_displacement = ">"
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_>{f}
+
+    Finally, ``arrow_style`` is used to specify the arrow style.  To
+    get a dashed arrow, for example, use "{-->}" as arrow style:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.arrow_style = "{-->}"
+    >>> print(str(astr))
+    \ar@/^12mm/@{-->}[dr]_{f}
+
+    Notes
+    =====
+
+    Instances of :class:`ArrowStringDescription` will be constructed
+    by :class:`XypicDiagramDrawer` and provided for further use in
+    formatters.  The user is not expected to construct instances of
+    :class:`ArrowStringDescription` themselves.
+
+    To be able to properly utilise this class, the reader is encouraged
+    to checkout the Xy-pic user guide, available at [Xypic].
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+
+    References
+    ==========
+
+    .. [Xypic] https://xy-pic.sourceforge.net/
+    """
+    def __init__(self, unit, curving, curving_amount, looping_start,
+                 looping_end, horizontal_direction, vertical_direction,
+                 label_position, label):
+        self.unit = unit
+        self.curving = curving
+        self.curving_amount = curving_amount
+        self.looping_start = looping_start
+        self.looping_end = looping_end
+        self.horizontal_direction = horizontal_direction
+        self.vertical_direction = vertical_direction
+        self.label_position = label_position
+        self.label = label
+
+        self.label_displacement = ""
+        self.arrow_style = ""
+
+        # This flag shows that the position of the label of this
+        # morphism was set while typesetting a curved morphism and
+        # should not be modified later.
+        self.forced_label_position = False
+
+    def __str__(self):
+        if self.curving:
+            curving_str = "@/%s%d%s/" % (self.curving, self.curving_amount,
+                                         self.unit)
+        else:
+            curving_str = ""
+
+        if self.looping_start and self.looping_end:
+            looping_str = "@(%s,%s)" % (self.looping_start, self.looping_end)
+        else:
+            looping_str = ""
+
+        if self.arrow_style:
+
+            style_str = "@" + self.arrow_style
+        else:
+            style_str = ""
+
+        return "\\ar%s%s%s[%s%s]%s%s{%s}" % \
+               (curving_str, looping_str, style_str, self.horizontal_direction,
+                self.vertical_direction, self.label_position,
+                self.label_displacement, self.label)
+
+
+class XypicDiagramDrawer:
+    r"""
+    Given a :class:`~.Diagram` and the corresponding
+    :class:`DiagramGrid`, produces the Xy-pic representation of the
+    diagram.
+
+    The most important method in this class is ``draw``.  Consider the
+    following triangle diagram:
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+    To draw this diagram, its objects need to be laid out with a
+    :class:`DiagramGrid`::
+
+    >>> grid = DiagramGrid(diagram)
+
+    Finally, the drawing:
+
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    For further details see the docstring of this method.
+
+    To control the appearance of the arrows, formatters are used.  The
+    dictionary ``arrow_formatters`` maps morphisms to formatter
+    functions.  A formatter is accepts an
+    :class:`ArrowStringDescription` and is allowed to modify any of
+    the arrow properties exposed thereby.  For example, to have all
+    morphisms with the property ``unique`` appear as dashed arrows,
+    and to have their names prepended with `\exists !`, the following
+    should be done:
+
+    >>> def formatter(astr):
+    ...   astr.label = r"\exists !" + astr.label
+    ...   astr.arrow_style = "{-->}"
+    >>> drawer.arrow_formatters["unique"] = formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_{\exists !g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    To modify the appearance of all arrows in the diagram, set
+    ``default_arrow_formatter``.  For example, to place all morphism
+    labels a little bit farther from the arrow head so that they look
+    more centred, do as follows:
+
+    >>> def default_formatter(astr):
+    ...   astr.label_displacement = "(0.45)"
+    >>> drawer.default_arrow_formatter = default_formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_(0.45){\exists !g\circ f} \ar[r]^(0.45){f} & B \ar[ld]^(0.45){g} \\
+    C &
+    }
+
+    In some diagrams some morphisms are drawn as curved arrows.
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> E = Object("E")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+    >>> grid = DiagramGrid(diagram)
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_3mm/[ll]_{h} \\
+    & C &
+    }
+
+    To control how far the morphisms are curved by default, one can
+    use the ``unit`` and ``default_curving_amount`` attributes:
+
+    >>> drawer.unit = "cm"
+    >>> drawer.default_curving_amount = 1
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_1cm/[ll]_{h} \\
+    & C &
+    }
+
+    In some diagrams, there are multiple curved morphisms between the
+    same two objects.  To control by how much the curving changes
+    between two such successive morphisms, use
+    ``default_curving_step``:
+
+    >>> drawer.default_curving_step = 1
+    >>> h1 = NamedMorphism(A, D, "h1")
+    >>> diagram = Diagram([f, g, h, k, h1])
+    >>> grid = DiagramGrid(diagram)
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} \ar@/^1cm/[rr]^{h_{1}} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_2cm/[ll]_{h} \\
+    & C &
+    }
+
+    The default value of ``default_curving_step`` is 4 units.
+
+    See Also
+    ========
+
+    draw, ArrowStringDescription
+    """
+    def __init__(self):
+        self.unit = "mm"
+        self.default_curving_amount = 3
+        self.default_curving_step = 4
+
+        # This dictionary maps properties to the corresponding arrow
+        # formatters.
+        self.arrow_formatters = {}
+
+        # This is the default arrow formatter which will be applied to
+        # each arrow independently of its properties.
+        self.default_arrow_formatter = None
+
+    @staticmethod
+    def _process_loop_morphism(i, j, grid, morphisms_str_info, object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a loop morphism.  This function is invoked
+        from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        # This is a loop morphism.  Count how many morphisms stick
+        # in each of the four quadrants.  Note that straight
+        # vertical and horizontal morphisms count in two quadrants
+        # at the same time (i.e., a morphism going up counts both
+        # in the first and the second quadrants).
+
+        # The usual numbering (counterclockwise) of quadrants
+        # applies.
+        quadrant = [0, 0, 0, 0]
+
+        obj = grid[i, j]
+
+        for m, m_str_info in morphisms_str_info.items():
+            if (m.domain == obj) and (m.codomain == obj):
+                # That's another loop morphism.  Check how it
+                # loops and mark the corresponding quadrants as
+                # busy.
+                (l_s, l_e) = (m_str_info.looping_start, m_str_info.looping_end)
+
+                if (l_s, l_e) == ("r", "u"):
+                    quadrant[0] += 1
+                elif (l_s, l_e) == ("u", "l"):
+                    quadrant[1] += 1
+                elif (l_s, l_e) == ("l", "d"):
+                    quadrant[2] += 1
+                elif (l_s, l_e) == ("d", "r"):
+                    quadrant[3] += 1
+
+                continue
+            if m.domain == obj:
+                (end_i, end_j) = object_coords[m.codomain]
+                goes_out = True
+            elif m.codomain == obj:
+                (end_i, end_j) = object_coords[m.domain]
+                goes_out = False
+            else:
+                continue
+
+            d_i = end_i - i
+            d_j = end_j - j
+            m_curving = m_str_info.curving
+
+            if (d_i != 0) and (d_j != 0):
+                # This is really a diagonal morphism.  Detect the
+                # quadrant.
+                if (d_i > 0) and (d_j > 0):
+                    quadrant[0] += 1
+                elif (d_i > 0) and (d_j < 0):
+                    quadrant[1] += 1
+                elif (d_i < 0) and (d_j < 0):
+                    quadrant[2] += 1
+                elif (d_i < 0) and (d_j > 0):
+                    quadrant[3] += 1
+            elif d_i == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the upper one and which is
+                # the lower one.
+                if d_j > 0:
+                    if goes_out:
+                        upper_quadrant = 0
+                        lower_quadrant = 3
+                    else:
+                        upper_quadrant = 3
+                        lower_quadrant = 0
+                else:
+                    if goes_out:
+                        upper_quadrant = 2
+                        lower_quadrant = 1
+                    else:
+                        upper_quadrant = 1
+                        lower_quadrant = 2
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[upper_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[lower_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[upper_quadrant] += 1
+                    quadrant[lower_quadrant] += 1
+            elif d_j == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the left one and which is
+                # the right one.
+                if d_i < 0:
+                    if goes_out:
+                        left_quadrant = 1
+                        right_quadrant = 0
+                    else:
+                        left_quadrant = 0
+                        right_quadrant = 1
+                else:
+                    if goes_out:
+                        left_quadrant = 3
+                        right_quadrant = 2
+                    else:
+                        left_quadrant = 2
+                        right_quadrant = 3
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[left_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[right_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[left_quadrant] += 1
+                    quadrant[right_quadrant] += 1
+
+        # Pick the freest quadrant to curve our morphism into.
+        freest_quadrant = 0
+        for i in range(4):
+            if quadrant[i] < quadrant[freest_quadrant]:
+                freest_quadrant = i
+
+        # Now set up proper looping.
+        (looping_start, looping_end) = [("r", "u"), ("u", "l"), ("l", "d"),
+                                        ("d", "r")][freest_quadrant]
+
+        return (curving, label_pos, looping_start, looping_end)
+
+    @staticmethod
+    def _process_horizontal_morphism(i, j, target_j, grid, morphisms_str_info,
+                                     object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a horizontal morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # The arrow is horizontal.  Check if it goes from left to
+        # right (``backwards == False``) or from right to left
+        # (``backwards == True``).
+        backwards = False
+        start = j
+        end = target_j
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out
+        # upwards, and how many stick out downwards.
+        #
+        # For example, consider the situation:
+        #
+        #    B1 C1
+        #    |  |
+        # A--B--C--D
+        #    |
+        #    B2
+        #
+        # Between the objects `A` and `D` there are two objects:
+        # `B` and `C`.  Further, there are two morphisms which
+        # stick out upward (the ones between `B1` and `B` and
+        # between `C` and `C1`) and one morphism which sticks out
+        # downward (the one between `B and `B2`).
+        #
+        # We need this information to decide how to curve the
+        # arrow between `A` and `D`.  First of all, since there
+        # are two objects between `A` and `D``, we must curve the
+        # arrow.  Then, we will have it curve downward, because
+        # there is more space (less morphisms stick out downward
+        # than upward).
+        up = []
+        down = []
+        straight_horizontal = []
+        for k in range(start + 1, end):
+            obj = grid[i, k]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_i > i:
+                    down.append(m)
+                elif end_i < i:
+                    up.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight horizontal morphism,
+                    # because it has no curving.
+                    straight_horizontal.append(m)
+
+        if len(up) < len(down):
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the lower side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the upper side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    @staticmethod
+    def _process_vertical_morphism(i, j, target_i, grid, morphisms_str_info,
+                                   object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a vertical morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # This arrow is vertical.  Check if it goes from top to
+        # bottom (``backwards == False``) or from bottom to top
+        # (``backwards == True``).
+        backwards = False
+        start = i
+        end = target_i
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out to
+        # the left, and how many stick out to the right.
+        #
+        # See the corresponding comment in the previous branch of
+        # this if-statement for more details.
+        left = []
+        right = []
+        straight_vertical = []
+        for k in range(start + 1, end):
+            obj = grid[k, j]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_j > j:
+                    right.append(m)
+                elif end_j < j:
+                    left.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight vertical morphism,
+                    # because it has no curving.
+                    straight_vertical.append(m)
+
+        if len(left) < len(right):
+            # More morphisms stick out to the left than to the
+            # right, let's curve the morphism to the right.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the left side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out to the right than to the
+            # left, let's curve the morphism to the left.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the right side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    def _process_morphism(self, diagram, grid, morphism, object_coords,
+                          morphisms, morphisms_str_info):
+        """
+        Given the required information, produces the string
+        representation of ``morphism``.
+        """
+        def repeat_string_cond(times, str_gt, str_lt):
+            """
+            If ``times > 0``, repeats ``str_gt`` ``times`` times.
+            Otherwise, repeats ``str_lt`` ``-times`` times.
+            """
+            if times > 0:
+                return str_gt * times
+            else:
+                return str_lt * (-times)
+
+        def count_morphisms_undirected(A, B):
+            """
+            Counts how many processed morphisms there are between the
+            two supplied objects.
+            """
+            return len([m for m in morphisms_str_info
+                        if {m.domain, m.codomain} == {A, B}])
+
+        def count_morphisms_filtered(dom, cod, curving):
+            """
+            Counts the processed morphisms which go out of ``dom``
+            into ``cod`` with curving ``curving``.
+            """
+            return len([m for m, m_str_info in morphisms_str_info.items()
+                        if (m.domain, m.codomain) == (dom, cod) and
+                        (m_str_info.curving == curving)])
+
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        # We now need to determine the direction of
+        # the arrow.
+        delta_i = target_i - i
+        delta_j = target_j - j
+        vertical_direction = repeat_string_cond(delta_i,
+                                                "d", "u")
+        horizontal_direction = repeat_string_cond(delta_j,
+                                                  "r", "l")
+
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        if (delta_i == 0) and (delta_j == 0):
+            # This is a loop morphism.
+            (curving, label_pos, looping_start,
+             looping_end) = XypicDiagramDrawer._process_loop_morphism(
+                 i, j, grid, morphisms_str_info, object_coords)
+        elif (delta_i == 0) and (abs(j - target_j) > 1):
+            # This is a horizontal morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_horizontal_morphism(
+                i, j, target_j, grid, morphisms_str_info, object_coords)
+        elif (delta_j == 0) and (abs(i - target_i) > 1):
+            # This is a vertical morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_vertical_morphism(
+                i, j, target_i, grid, morphisms_str_info, object_coords)
+
+        count = count_morphisms_undirected(morphism.domain, morphism.codomain)
+        curving_amount = ""
+        if curving:
+            # This morphisms should be curved anyway.
+            curving_amount = self.default_curving_amount + count * \
+                self.default_curving_step
+        elif count:
+            # There are no objects between the domain and codomain of
+            # the current morphism, but this is not there already are
+            # some morphisms with the same domain and codomain, so we
+            # have to curve this one.
+            curving = "^"
+            filtered_morphisms = count_morphisms_filtered(
+                morphism.domain, morphism.codomain, curving)
+            curving_amount = self.default_curving_amount + \
+                filtered_morphisms * \
+                self.default_curving_step
+
+        # Let's now get the name of the morphism.
+        morphism_name = ""
+        if isinstance(morphism, IdentityMorphism):
+            morphism_name = "id_{%s}" + latex(grid[i, j])
+        elif isinstance(morphism, CompositeMorphism):
+            component_names = [latex(Symbol(component.name)) for
+                               component in morphism.components]
+            component_names.reverse()
+            morphism_name = "\\circ ".join(component_names)
+        elif isinstance(morphism, NamedMorphism):
+            morphism_name = latex(Symbol(morphism.name))
+
+        return ArrowStringDescription(
+            self.unit, curving, curving_amount, looping_start,
+            looping_end, horizontal_direction, vertical_direction,
+            label_pos, morphism_name)
+
+    @staticmethod
+    def _check_free_space_horizontal(dom_i, dom_j, cod_j, grid):
+        """
+        For a horizontal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        if dom_j < cod_j:
+            (start, end) = (dom_j, cod_j)
+            backwards = False
+        else:
+            (start, end) = (cod_j, dom_j)
+            backwards = True
+
+        # Check for free space above.
+        if dom_i == 0:
+            free_up = True
+        else:
+            free_up = all(grid[dom_i - 1, j] for j in
+                          range(start, end + 1))
+
+        # Check for free space below.
+        if dom_i == grid.height - 1:
+            free_down = True
+        else:
+            free_down = not any(grid[dom_i + 1, j] for j in
+                                range(start, end + 1))
+
+        return (free_up, free_down, backwards)
+
+    @staticmethod
+    def _check_free_space_vertical(dom_i, cod_i, dom_j, grid):
+        """
+        For a vertical morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) to the left of the
+        morphism or to the right of it.
+        """
+        if dom_i < cod_i:
+            (start, end) = (dom_i, cod_i)
+            backwards = False
+        else:
+            (start, end) = (cod_i, dom_i)
+            backwards = True
+
+        # Check if there's space to the left.
+        if dom_j == 0:
+            free_left = True
+        else:
+            free_left = not any(grid[i, dom_j - 1] for i in
+                                range(start, end + 1))
+
+        if dom_j == grid.width - 1:
+            free_right = True
+        else:
+            free_right = not any(grid[i, dom_j + 1] for i in
+                                 range(start, end + 1))
+
+        return (free_left, free_right, backwards)
+
+    @staticmethod
+    def _check_free_space_diagonal(dom_i, cod_i, dom_j, cod_j, grid):
+        """
+        For a diagonal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        def abs_xrange(start, end):
+            if start < end:
+                return range(start, end + 1)
+            else:
+                return range(end, start + 1)
+
+        if dom_i < cod_i and dom_j < cod_j:
+            # This morphism goes from top-left to
+            # bottom-right.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = False
+        elif dom_i > cod_i and dom_j > cod_j:
+            # This morphism goes from bottom-right to
+            # top-left.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = True
+        if dom_i < cod_i and dom_j > cod_j:
+            # This morphism goes from top-right to
+            # bottom-left.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = True
+        elif dom_i > cod_i and dom_j < cod_j:
+            # This morphism goes from bottom-left to
+            # top-right.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = False
+
+        # This is an attempt at a fast and furious strategy to
+        # decide where there is free space on the two sides of
+        # a diagonal morphism.  For a diagonal morphism
+        # starting at ``(start_i, start_j)`` and ending at
+        # ``(end_i, end_j)`` the rectangle defined by these
+        # two points is considered.  The slope of the diagonal
+        # ``alpha`` is then computed.  Then, for every cell
+        # ``(i, j)`` within the rectangle, the slope
+        # ``alpha1`` of the line through ``(start_i,
+        # start_j)`` and ``(i, j)`` is considered.  If
+        # ``alpha1`` is between 0 and ``alpha``, the point
+        # ``(i, j)`` is above the diagonal, if ``alpha1`` is
+        # between ``alpha`` and infinity, the point is below
+        # the diagonal.  Also note that, with some beforehand
+        # precautions, this trick works for both the main and
+        # the secondary diagonals of the rectangle.
+
+        # I have considered the possibility to only follow the
+        # shorter diagonals immediately above and below the
+        # main (or secondary) diagonal.  This, however,
+        # wouldn't have resulted in much performance gain or
+        # better detection of outer edges, because of
+        # relatively small sizes of diagram grids, while the
+        # code would have become harder to understand.
+
+        alpha = float(end_i - start_i)/(end_j - start_j)
+        free_up = True
+        free_down = True
+        for i in abs_xrange(start_i, end_i):
+            if not free_up and not free_down:
+                break
+
+            for j in abs_xrange(start_j, end_j):
+                if not free_up and not free_down:
+                    break
+
+                if (i, j) == (start_i, start_j):
+                    continue
+
+                if j == start_j:
+                    alpha1 = "inf"
+                else:
+                    alpha1 = float(i - start_i)/(j - start_j)
+
+                if grid[i, j]:
+                    if (alpha1 == "inf") or (abs(alpha1) > abs(alpha)):
+                        free_down = False
+                    elif abs(alpha1) < abs(alpha):
+                        free_up = False
+
+        return (free_up, free_down, backwards)
+
+    def _push_labels_out(self, morphisms_str_info, grid, object_coords):
+        """
+        For all straight morphisms which form the visual boundary of
+        the laid out diagram, puts their labels on their outer sides.
+        """
+        def set_label_position(free1, free2, pos1, pos2, backwards, m_str_info):
+            """
+            Given the information about room available to one side and
+            to the other side of a morphism (``free1`` and ``free2``),
+            sets the position of the morphism label in such a way that
+            it is on the freer side.  This latter operations involves
+            choice between ``pos1`` and ``pos2``, taking ``backwards``
+            in consideration.
+
+            Thus this function will do nothing if either both ``free1
+            == True`` and ``free2 == True`` or both ``free1 == False``
+            and ``free2 == False``.  In either case, choosing one side
+            over the other presents no advantage.
+            """
+            if backwards:
+                (pos1, pos2) = (pos2, pos1)
+
+            if free1 and not free2:
+                m_str_info.label_position = pos1
+            elif free2 and not free1:
+                m_str_info.label_position = pos2
+
+        for m, m_str_info in morphisms_str_info.items():
+            if m_str_info.curving or m_str_info.forced_label_position:
+                # This is either a curved morphism, and curved
+                # morphisms have other magic, or the position of this
+                # label has already been fixed.
+                continue
+
+            if m.domain == m.codomain:
+                # This is a loop morphism, their labels, again have a
+                # different magic.
+                continue
+
+            (dom_i, dom_j) = object_coords[m.domain]
+            (cod_i, cod_j) = object_coords[m.codomain]
+
+            if dom_i == cod_i:
+                # Horizontal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_horizontal(
+                     dom_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+            elif dom_j == cod_j:
+                # Vertical morphism.
+                (free_left, free_right,
+                 backwards) = XypicDiagramDrawer._check_free_space_vertical(
+                     dom_i, cod_i, dom_j, grid)
+
+                set_label_position(free_left, free_right, "_", "^",
+                                   backwards, m_str_info)
+            else:
+                # A diagonal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_diagonal(
+                     dom_i, cod_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+
+    @staticmethod
+    def _morphism_sort_key(morphism, object_coords):
+        """
+        Provides a morphism sorting key such that horizontal or
+        vertical morphisms between neighbouring objects come
+        first, then horizontal or vertical morphisms between more
+        far away objects, and finally, all other morphisms.
+        """
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        if morphism.domain == morphism.codomain:
+            # Loop morphisms should get after diagonal morphisms
+            # so that the proper direction in which to curve the
+            # loop can be determined.
+            return (3, 0, default_sort_key(morphism))
+
+        if target_i == i:
+            return (1, abs(target_j - j), default_sort_key(morphism))
+
+        if target_j == j:
+            return (1, abs(target_i - i), default_sort_key(morphism))
+
+        # Diagonal morphism.
+        return (2, 0, default_sort_key(morphism))
+
+    @staticmethod
+    def _build_xypic_string(diagram, grid, morphisms,
+                            morphisms_str_info, diagram_format):
+        """
+        Given a collection of :class:`ArrowStringDescription`
+        describing the morphisms of a diagram and the object layout
+        information of a diagram, produces the final Xy-pic picture.
+        """
+        # Build the mapping between objects and morphisms which have
+        # them as domains.
+        object_morphisms = {}
+        for obj in diagram.objects:
+            object_morphisms[obj] = []
+        for morphism in morphisms:
+            object_morphisms[morphism.domain].append(morphism)
+
+        result = "\\xymatrix%s{\n" % diagram_format
+
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if obj:
+                    result += latex(obj) + " "
+
+                    morphisms_to_draw = object_morphisms[obj]
+                    for morphism in morphisms_to_draw:
+                        result += str(morphisms_str_info[morphism]) + " "
+
+                # Don't put the & after the last column.
+                if j < grid.width - 1:
+                    result += "& "
+
+            # Don't put the line break after the last row.
+            if i < grid.height - 1:
+                result += "\\\\"
+            result += "\n"
+
+        result += "}\n"
+
+        return result
+
+    def draw(self, diagram, grid, masked=None, diagram_format=""):
+        r"""
+        Returns the Xy-pic representation of ``diagram`` laid out in
+        ``grid``.
+
+        Consider the following simple triangle diagram.
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+        To draw this diagram, its objects need to be laid out with a
+        :class:`DiagramGrid`::
+
+        >>> grid = DiagramGrid(diagram)
+
+        Finally, the drawing:
+
+        >>> drawer = XypicDiagramDrawer()
+        >>> print(drawer.draw(diagram, grid))
+        \xymatrix{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        The argument ``masked`` can be used to skip morphisms in the
+        presentation of the diagram:
+
+        >>> print(drawer.draw(diagram, grid, masked=[g * f]))
+        \xymatrix{
+        A \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        Finally, the ``diagram_format`` argument can be used to
+        specify the format string of the diagram.  For example, to
+        increase the spacing by 1 cm, proceeding as follows:
+
+        >>> print(drawer.draw(diagram, grid, diagram_format="@+1cm"))
+        \xymatrix@+1cm{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        """
+        # This method works in several steps.  It starts by removing
+        # the masked morphisms, if necessary, and then maps objects to
+        # their positions in the grid (coordinate tuples).  Remember
+        # that objects are unique in ``Diagram`` and in the layout
+        # produced by ``DiagramGrid``, so every object is mapped to a
+        # single coordinate pair.
+        #
+        # The next step is the central step and is concerned with
+        # analysing the morphisms of the diagram and deciding how to
+        # draw them.  For example, how to curve the arrows is decided
+        # at this step.  The bulk of the analysis is implemented in
+        # ``_process_morphism``, to the result of which the
+        # appropriate formatters are applied.
+        #
+        # The result of the previous step is a list of
+        # ``ArrowStringDescription``.  After the analysis and
+        # application of formatters, some extra logic tries to assure
+        # better positioning of morphism labels (for example, an
+        # attempt is made to avoid the situations when arrows cross
+        # labels).  This functionality constitutes the next step and
+        # is implemented in ``_push_labels_out``.  Note that label
+        # positions which have been set via a formatter are not
+        # affected in this step.
+        #
+        # Finally, at the closing step, the array of
+        # ``ArrowStringDescription`` and the layout information
+        # incorporated in ``DiagramGrid`` are combined to produce the
+        # resulting Xy-pic picture.  This part of code lies in
+        # ``_build_xypic_string``.
+
+        if not masked:
+            morphisms_props = grid.morphisms
+        else:
+            morphisms_props = {}
+            for m, props in grid.morphisms.items():
+                if m in masked:
+                    continue
+                morphisms_props[m] = props
+
+        # Build the mapping between objects and their position in the
+        # grid.
+        object_coords = {}
+        for i in range(grid.height):
+            for j in range(grid.width):
+                if grid[i, j]:
+                    object_coords[grid[i, j]] = (i, j)
+
+        morphisms = sorted(morphisms_props,
+                           key=lambda m: XypicDiagramDrawer._morphism_sort_key(
+                               m, object_coords))
+
+        # Build the tuples defining the string representations of
+        # morphisms.
+        morphisms_str_info = {}
+        for morphism in morphisms:
+            string_description = self._process_morphism(
+                diagram, grid, morphism, object_coords, morphisms,
+                morphisms_str_info)
+
+            if self.default_arrow_formatter:
+                self.default_arrow_formatter(string_description)
+
+            for prop in morphisms_props[morphism]:
+                # prop is a Symbol.  TODO: Find out why.
+                if prop.name in self.arrow_formatters:
+                    formatter = self.arrow_formatters[prop.name]
+                    formatter(string_description)
+
+            morphisms_str_info[morphism] = string_description
+
+        # Reposition the labels a bit.
+        self._push_labels_out(morphisms_str_info, grid, object_coords)
+
+        return XypicDiagramDrawer._build_xypic_string(
+            diagram, grid, morphisms, morphisms_str_info, diagram_format)
+
+
+def xypic_draw_diagram(diagram, masked=None, diagram_format="",
+                       groups=None, **hints):
+    r"""
+    Provides a shortcut combining :class:`DiagramGrid` and
+    :class:`XypicDiagramDrawer`.  Returns an Xy-pic presentation of
+    ``diagram``.  The argument ``masked`` is a list of morphisms which
+    will be not be drawn.  The argument ``diagram_format`` is the
+    format string inserted after "\xymatrix".  ``groups`` should be a
+    set of logical groups.  The ``hints`` will be passed directly to
+    the constructor of :class:`DiagramGrid`.
+
+    For more information about the arguments, see the docstrings of
+    :class:`DiagramGrid` and ``XypicDiagramDrawer.draw``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import xypic_draw_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+    >>> print(xypic_draw_diagram(diagram))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    See Also
+    ========
+
+    XypicDiagramDrawer, DiagramGrid
+    """
+    grid = DiagramGrid(diagram, groups, **hints)
+    drawer = XypicDiagramDrawer()
+    return drawer.draw(diagram, grid, masked, diagram_format)
+
+
+@doctest_depends_on(exe=('latex', 'dvipng'), modules=('pyglet',))
+def preview_diagram(diagram, masked=None, diagram_format="", groups=None,
+                    output='png', viewer=None, euler=True, **hints):
+    """
+    Combines the functionality of ``xypic_draw_diagram`` and
+    ``sympy.printing.preview``.  The arguments ``masked``,
+    ``diagram_format``, ``groups``, and ``hints`` are passed to
+    ``xypic_draw_diagram``, while ``output``, ``viewer, and ``euler``
+    are passed to ``preview``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import preview_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> preview_diagram(d)
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+    """
+    from sympy.printing import preview
+    latex_output = xypic_draw_diagram(diagram, masked, diagram_format,
+                                      groups, **hints)
+    preview(latex_output, output, viewer, euler, ("xypic",))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/categories/tests/test_baseclasses.py

@@ -0,0 +1,209 @@
+from sympy.categories import (Object, Morphism, IdentityMorphism,
+                              NamedMorphism, CompositeMorphism,
+                              Diagram, Category)
+from sympy.categories.baseclasses import Class
+from sympy.testing.pytest import raises
+from sympy.core.containers import (Dict, Tuple)
+from sympy.sets import EmptySet
+from sympy.sets.sets import FiniteSet
+
+
+def test_morphisms():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    # Test the base morphism.
+    f = NamedMorphism(A, B, "f")
+    assert f.domain == A
+    assert f.codomain == B
+    assert f == NamedMorphism(A, B, "f")
+
+    # Test identities.
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+    assert id_A.domain == A
+    assert id_A.codomain == A
+    assert id_A == IdentityMorphism(A)
+    assert id_A != id_B
+
+    # Test named morphisms.
+    g = NamedMorphism(B, C, "g")
+    assert g.name == "g"
+    assert g != f
+    assert g == NamedMorphism(B, C, "g")
+    assert g != NamedMorphism(B, C, "f")
+
+    # Test composite morphisms.
+    assert f == CompositeMorphism(f)
+
+    k = g.compose(f)
+    assert k.domain == A
+    assert k.codomain == C
+    assert k.components == Tuple(f, g)
+    assert g * f == k
+    assert CompositeMorphism(f, g) == k
+
+    assert CompositeMorphism(g * f) == g * f
+
+    # Test the associativity of composition.
+    h = NamedMorphism(C, D, "h")
+
+    p = h * g
+    u = h * g * f
+
+    assert h * k == u
+    assert p * f == u
+    assert CompositeMorphism(f, g, h) == u
+
+    # Test flattening.
+    u2 = u.flatten("u")
+    assert isinstance(u2, NamedMorphism)
+    assert u2.name == "u"
+    assert u2.domain == A
+    assert u2.codomain == D
+
+    # Test identities.
+    assert f * id_A == f
+    assert id_B * f == f
+    assert id_A * id_A == id_A
+    assert CompositeMorphism(id_A) == id_A
+
+    # Test bad compositions.
+    raises(ValueError, lambda: f * g)
+
+    raises(TypeError, lambda: f.compose(None))
+    raises(TypeError, lambda: id_A.compose(None))
+    raises(TypeError, lambda: f * None)
+    raises(TypeError, lambda: id_A * None)
+
+    raises(TypeError, lambda: CompositeMorphism(f, None, 1))
+
+    raises(ValueError, lambda: NamedMorphism(A, B, ""))
+    raises(NotImplementedError, lambda: Morphism(A, B))
+
+
+def test_diagram():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+
+    empty = EmptySet
+
+    # Test the addition of identities.
+    d1 = Diagram([f])
+
+    assert d1.objects == FiniteSet(A, B)
+    assert d1.hom(A, B) == (FiniteSet(f), empty)
+    assert d1.hom(A, A) == (FiniteSet(id_A), empty)
+    assert d1.hom(B, B) == (FiniteSet(id_B), empty)
+
+    assert d1 == Diagram([id_A, f])
+    assert d1 == Diagram([f, f])
+
+    # Test the addition of composites.
+    d2 = Diagram([f, g])
+    homAC = d2.hom(A, C)[0]
+
+    assert d2.objects == FiniteSet(A, B, C)
+    assert g * f in d2.premises.keys()
+    assert homAC == FiniteSet(g * f)
+
+    # Test equality, inequality and hash.
+    d11 = Diagram([f])
+
+    assert d1 == d11
+    assert d1 != d2
+    assert hash(d1) == hash(d11)
+
+    d11 = Diagram({f: "unique"})
+    assert d1 != d11
+
+    # Make sure that (re-)adding composites (with new properties)
+    # works as expected.
+    d = Diagram([f, g], {g * f: "unique"})
+    assert d.conclusions == Dict({g * f: FiniteSet("unique")})
+
+    # Check the hom-sets when there are premises and conclusions.
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+    d = Diagram([f, g], [g * f])
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+
+    # Check how the properties of composite morphisms are computed.
+    d = Diagram({f: ["unique", "isomorphism"], g: "unique"})
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check that conclusion morphisms with new objects are not allowed.
+    d = Diagram([f], [g])
+    assert d.conclusions == Dict({})
+
+    # Test an empty diagram.
+    d = Diagram()
+    assert d.premises == Dict({})
+    assert d.conclusions == Dict({})
+    assert d.objects == empty
+
+    # Check a SymPy Dict object.
+    d = Diagram(Dict({f: FiniteSet("unique", "isomorphism"), g: "unique"}))
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check the addition of components of composite morphisms.
+    d = Diagram([g * f])
+    assert f in d.premises
+    assert g in d.premises
+
+    # Check subdiagrams.
+    d = Diagram([f, g], {g * f: "unique"})
+
+    d1 = Diagram([f])
+    assert d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([NamedMorphism(B, A, "f'")])
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d1 = Diagram([f, g], {g * f: ["unique", "something"]})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram({f: "blooh"})
+    d1 = Diagram({f: "bleeh"})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([f, g], {f: "unique", g * f: "veryunique"})
+    d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+    assert d1 == Diagram([f], {f: "unique"})
+    raises(ValueError, lambda: d.subdiagram_from_objects(FiniteSet(A,
+           Object("D"))))
+
+    raises(ValueError, lambda: Diagram({IdentityMorphism(A): "unique"}))
+
+
+def test_category():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d1 = Diagram([f, g])
+    d2 = Diagram([f])
+
+    objects = d1.objects | d2.objects
+
+    K = Category("K", objects, commutative_diagrams=[d1, d2])
+
+    assert K.name == "K"
+    assert K.objects == Class(objects)
+    assert K.commutative_diagrams == FiniteSet(d1, d2)
+
+    raises(ValueError, lambda: Category(""))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/categories/tests/test_drawing.py

@@ -0,0 +1,919 @@
+from sympy.categories.diagram_drawing import _GrowableGrid, ArrowStringDescription
+from sympy.categories import (DiagramGrid, Object, NamedMorphism,
+                              Diagram, XypicDiagramDrawer, xypic_draw_diagram)
+from sympy.sets.sets import FiniteSet
+
+
+def test_GrowableGrid():
+    grid = _GrowableGrid(1, 2)
+
+    # Check dimensions.
+    assert grid.width == 1
+    assert grid.height == 2
+
+    # Check initialization of elements.
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+
+    # Check assignment to elements.
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+
+    # Check appending a row.
+    grid.append_row()
+
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    # Check appending a column.
+    grid.append_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] is None
+    assert grid[2, 1] is None
+
+    grid = _GrowableGrid(1, 2)
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    # Check prepending a row.
+    grid.prepend_row()
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] == 1
+    assert grid[2, 0] == "two"
+
+    # Check prepending a column.
+    grid.prepend_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] == 1
+    assert grid[2, 1] == "two"
+
+
+def test_DiagramGrid():
+    # Set up some objects and morphisms.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+
+    # A one-morphism diagram.
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid.morphisms == {f: FiniteSet()}
+
+    # A triangle.
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(),
+                              g * f: FiniteSet("unique")}
+
+    # A triangle with a "loop" morphism.
+    l_A = NamedMorphism(A, A, "l_A")
+    d = Diagram([f, g, l_A])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), l_A: FiniteSet()}
+
+    # A simple diagram.
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == D
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    assert str(grid) == '[[Object("A"), Object("B"), Object("D")], ' \
+        '[None, Object("C"), None]]'
+
+    # A chain of morphisms.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    k = NamedMorphism(D, E, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A square.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, D, "g")
+    h = NamedMorphism(A, C, "h")
+    k = NamedMorphism(C, D, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A strange diagram which resulted from a typo when creating a
+    # test for five lemma, but which allowed to stop one extra problem
+    # in the algorithm.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    # These 4 morphisms should be between primed objects.
+    j = NamedMorphism(A, B, "j")
+    k = NamedMorphism(B, C, "k")
+    l = NamedMorphism(C, D, "l")
+    m = NamedMorphism(D, E, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 4
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[2, 0] == C_
+    assert grid[2, 1] == D
+    assert grid[2, 2] == D_
+    assert grid[3, 0] is None
+    assert grid[3, 1] == E
+    assert grid[3, 2] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A cube.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A5
+    assert grid[0, 2] == A6
+    assert grid[0, 3] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == A1
+    assert grid[1, 2] == A2
+    assert grid[1, 3] is None
+    assert grid[2, 0] == A7
+    assert grid[2, 1] == A3
+    assert grid[2, 2] == A4
+    assert grid[2, 3] == A8
+
+    morphisms = {}
+    for m in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A line diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # Test the transposed version.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+
+    assert grid.width == 1
+    assert grid.height == 5
+    assert grid[0, 0] == A
+    assert grid[1, 0] == B
+    assert grid[2, 0] == C
+    assert grid[3, 0] == D
+    assert grid[4, 0] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # A pullback.
+    m1 = NamedMorphism(A, B, "m1")
+    m2 = NamedMorphism(A, C, "m2")
+    s1 = NamedMorphism(B, D, "s1")
+    s2 = NamedMorphism(C, D, "s2")
+    f1 = NamedMorphism(E, B, "f1")
+    f2 = NamedMorphism(E, C, "f2")
+    g = NamedMorphism(E, A, "g")
+
+    d = Diagram([m1, m2, s1, s2, f1, f2], {g: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == E
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid[1, 2] is None
+
+    morphisms = {g: FiniteSet("unique")}
+    for m in [m1, m2, s1, s2, f1, f2]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the pullback with sequential layout, just for stress
+    # testing.
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == D
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A
+    assert grid[0, 3] == C
+    assert grid[0, 4] == E
+    assert grid.morphisms == morphisms
+
+    # Test a pullback with object grouping.
+    grid = DiagramGrid(d, groups=FiniteSet(E, FiniteSet(A, B, C, D)))
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == E
+    assert grid[0, 1] == A
+    assert grid[0, 2] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid.morphisms == morphisms
+
+    # Five lemma, actually.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    j = NamedMorphism(A_, B_, "j")
+    k = NamedMorphism(B_, C_, "k")
+    l = NamedMorphism(C_, D_, "l")
+    m = NamedMorphism(D_, E_, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[0, 3] is None
+    assert grid[0, 4] is None
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[1, 3] == C_
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D
+    assert grid[2, 1] == E
+    assert grid[2, 2] is None
+    assert grid[2, 3] == D_
+    assert grid[2, 4] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping.
+    grid = DiagramGrid(d, FiniteSet(
+        FiniteSet(A, B, C, D, E), FiniteSet(A_, B_, C_, D_, E_)))
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping, but mixing containers
+    # to represent groups.
+    grid = DiagramGrid(d, [(A, B, C, D, E), {A_, B_, C_, D_, E_}])
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping and hints.
+    grid = DiagramGrid(d, {
+        FiniteSet(A, B, C, D, E): {"layout": "sequential",
+                                   "transpose": True},
+        FiniteSet(A_, B_, C_, D_, E_): {"layout": "sequential",
+                                        "transpose": True}},
+        transpose=True)
+
+    assert grid.width == 5
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid[1, 0] == A_
+    assert grid[1, 1] == B_
+    assert grid[1, 2] == C_
+    assert grid[1, 3] == D_
+    assert grid[1, 4] == E_
+    assert grid.morphisms == morphisms
+
+    # A two-triangle disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    f_ = NamedMorphism(A_, B_, "f")
+    g_ = NamedMorphism(B_, C_, "g")
+    d = Diagram([f, g, f_, g_], {g * f: "unique", g_ * f_: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A_
+    assert grid[0, 3] == B_
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid[1, 2] == C_
+    assert grid[1, 3] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), f_: FiniteSet(),
+                              g_: FiniteSet(), g * f: FiniteSet("unique"),
+                              g_ * f_: FiniteSet("unique")}
+
+    # A two-morphism disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(C, D, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet()}
+
+    # Test a one-object diagram.
+    f = NamedMorphism(A, A, "f")
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 1
+    assert grid.height == 1
+    assert grid[0, 0] == A
+
+    # Test a two-object disconnected diagram.
+    g = NamedMorphism(B, B, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+
+
+def test_DiagramGrid_pseudopod():
+    # Test a diagram in which even growing a pseudopod does not
+    # eventually help.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    F = Object("F")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f1 = NamedMorphism(A, B, "f1")
+    f2 = NamedMorphism(A, C, "f2")
+    f3 = NamedMorphism(A, D, "f3")
+    f4 = NamedMorphism(A, E, "f4")
+    f5 = NamedMorphism(A, A_, "f5")
+    f6 = NamedMorphism(A, B_, "f6")
+    f7 = NamedMorphism(A, C_, "f7")
+    f8 = NamedMorphism(A, D_, "f8")
+    f9 = NamedMorphism(A, E_, "f9")
+    f10 = NamedMorphism(A, F, "f10")
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] == E
+    assert grid[0, 1] == C
+    assert grid[0, 2] == C_
+    assert grid[0, 3] == E_
+    assert grid[0, 4] == F
+    assert grid[1, 0] == D
+    assert grid[1, 1] == A
+    assert grid[1, 2] == A_
+    assert grid[1, 3] is None
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D_
+    assert grid[2, 1] == B
+    assert grid[2, 2] == B_
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+
+    morphisms = {}
+    for f in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10]:
+        morphisms[f] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+
+def test_ArrowStringDescription():
+    astr = ArrowStringDescription("cm", "", None, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "^", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@/^12cm/[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@(r,u)@{-->}[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "_", 12, "", "", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@/_12cm/@{-->}[dr]_{f}"
+
+
+def test_XypicDiagramDrawer_line():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{f} & B \\ar[r]^{g} & C \\ar[r]^{h} & D \\ar[r]^{i} & E \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\\\\n" \
+        "B \\ar[d]^{g} \\\\\n" \
+        "C \\ar[d]^{h} \\\\\n" \
+        "D \\ar[d]^{i} \\\\\n" \
+        "E \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_triangle():
+    # A triangle diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]_{g\\circ f} \\ar[r]^{f} & B \\ar[ld]^{g} \\\\\n" \
+        "C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram, with a masked morphism.
+    assert drawer.draw(d, grid, masked=[g]) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B & \n" \
+        "}\n"
+
+    # The same diagram with a formatter for "unique".
+    def formatter(astr):
+        astr.label = "\\exists !" + astr.label
+        astr.arrow_style = "{-->}"
+
+    drawer.arrow_formatters["unique"] = formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^{\\exists !g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram with a default formatter.
+    def default_formatter(astr):
+        astr.label_displacement = "(0.45)"
+
+    drawer.default_arrow_formatter = default_formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^(0.45){\\exists !g\\circ f} \\ar[d]_(0.45){f} & C \\\\\n" \
+        "B \\ar[ru]_(0.45){g} & \n" \
+        "}\n"
+
+    # A triangle diagram with a lot of morphisms between the same
+    # objects.
+    f1 = NamedMorphism(B, A, "f1")
+    f2 = NamedMorphism(A, B, "f2")
+    g1 = NamedMorphism(C, B, "g1")
+    g2 = NamedMorphism(B, C, "g2")
+    d = Diagram([f, f1, f2, g, g1, g2], {f1 * g1: "unique", g2 * f2: "unique"})
+
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid, masked=[f1*g1*g2*f2, g2*f2*f1*g1]) == \
+        "\\xymatrix{\n" \
+        "A \\ar[r]^{g_{2}\\circ f_{2}} \\ar[d]_{f} \\ar@/^3mm/[d]^{f_{2}} " \
+        "& C \\ar@/^3mm/[l]^{f_{1}\\circ g_{1}} \\ar@/^3mm/[ld]^{g_{1}} \\\\\n" \
+        "B \\ar@/^3mm/[u]^{f_{1}} \\ar[ru]_{g} \\ar@/^3mm/[ru]^{g_{2}} & \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_cube():
+    # A cube diagram.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& A_{5} \\ar[r]^{f_{5}} \\ar[ldd]_{f_{6}} & A_{6} \\ar[rdd]^{f_{7}} " \
+        "& \\\\\n" \
+        "& A_{1} \\ar[r]^{f_{1}} \\ar[d]^{f_{2}} \\ar[u]^{f_{9}} & A_{2} " \
+        "\\ar[d]^{f_{3}} \\ar[u]_{f_{10}} & \\\\\n" \
+        "A_{7} \\ar@/_3mm/[rrr]_{f_{8}} & A_{3} \\ar[r]^{f_{3}} \\ar[l]_{f_{11}} " \
+        "& A_{4} \\ar[r]^{f_{11}} & A_{8} \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& & A_{7} \\ar@/^3mm/[ddd]^{f_{8}} \\\\\n" \
+        "A_{5} \\ar[d]_{f_{5}} \\ar[rru]^{f_{6}} & A_{1} \\ar[d]^{f_{1}} " \
+        "\\ar[r]^{f_{2}} \\ar[l]^{f_{9}} & A_{3} \\ar[d]_{f_{3}} " \
+        "\\ar[u]^{f_{11}} \\\\\n" \
+        "A_{6} \\ar[rrd]_{f_{7}} & A_{2} \\ar[r]^{f_{3}} \\ar[l]^{f_{10}} " \
+        "& A_{4} \\ar[d]_{f_{11}} \\\\\n" \
+        "& & A_{8} \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_curved_and_loops():
+    # A simple diagram, with a curved arrow.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} & B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_3mm/[ll]_{h} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # The same diagram, larger and rotated.
+    assert drawer.draw(d, grid, diagram_format="@+1cm@dr") == \
+        "\\xymatrix@+1cm@dr{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # A simple diagram with three curved arrows.
+    h1 = NamedMorphism(D, A, "h1")
+    h2 = NamedMorphism(A, D, "h2")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k, h1, h2])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} & \n" \
+        "}\n"
+
+    # The same diagram, with "loop" morphisms.
+    l_A = NamedMorphism(A, A, "l_A")
+    l_D = NamedMorphism(D, D, "l_D")
+    l_C = NamedMorphism(C, C, "l_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "& B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_7mm/[ll]_{h} " \
+        "\\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with "loop" morphisms, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object.
+    l_A_ = NamedMorphism(A, A, "n_A")
+    l_D_ = NamedMorphism(D, D, "n_D")
+    l_C_ = NamedMorphism(C, C, "n_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C, l_A_, l_D_, l_C_])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(l,d)[]^{n_{A}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} " \
+        "\\ar@/^3mm/@(d,r)[]^{n_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(u,l)[]^{n_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} \\ar@/^3mm/@(d,r)[]^{n_{D}} & \n" \
+        "}\n"
+
+
+def test_xypic_draw_diagram():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == xypic_draw_diagram(d, layout="sequential")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/codegen/__init__.py

@@ -0,0 +1,24 @@
+""" The ``sympy.codegen`` module contains classes and functions for building
+abstract syntax trees of algorithms. These trees may then be printed by the
+code-printers in ``sympy.printing``.
+
+There are several submodules available:
+- ``sympy.codegen.ast``: AST nodes useful across multiple languages.
+- ``sympy.codegen.cnodes``: AST nodes useful for the C family of languages.
+- ``sympy.codegen.fnodes``: AST nodes useful for Fortran.
+- ``sympy.codegen.cfunctions``: functions specific to C (C99 math functions)
+- ``sympy.codegen.ffunctions``: functions specific to Fortran (e.g. ``kind``).
+
+
+
+"""
+from .ast import (
+    Assignment, aug_assign, CodeBlock, For, Attribute, Variable, Declaration,
+    While, Scope, Print, FunctionPrototype, FunctionDefinition, FunctionCall
+)
+
+__all__ = [
+    'Assignment', 'aug_assign', 'CodeBlock', 'For', 'Attribute', 'Variable',
+    'Declaration', 'While', 'Scope', 'Print', 'FunctionPrototype',
+    'FunctionDefinition', 'FunctionCall',
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sympy/codegen/abstract_nodes.py

@@ -0,0 +1,18 @@
+"""This module provides containers for python objects that are valid
+printing targets but are not a subclass of SymPy's Printable.
+"""
+
+
+from sympy.core.containers import Tuple
+
+
+class List(Tuple):
+    """Represents a (frozen) (Python) list (for code printing purposes)."""
+    def __eq__(self, other):
+        if isinstance(other, list):
+            return self == List(*other)
+        else:
+            return self.args == other
+
+    def __hash__(self):
+        return super().__hash__()