+
    i/                     p   R t ^ RIHt ^ RIHt ^ RIHt ^ RIHt ^ RI	H
t
 ^ RIHtHtHtHtHt ^ RIHtHtHtHtHtHtHtHtHt ^ RIHt RR
 lt]P<                  R	3R lt]P<                  R	3R lt ]P<                  R	3R lt!]P<                  R	3R lt"]P<                  R	3R lt#]P<                  R	3R lt$R	# )af  
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

)Pow)S)Symbol)sympify)log)seccsccottancos)	sechcschcothtanhcoshasechacschatanhacoth)
filldedentNc                   ^ RI Hp Vf3   VP                  '       d   \        P                  M\        P
                  p \        P                  pV P                  \        \        \        \        .\        4      pVP                  \        \        \        \         .\"        4      pVP%                  \&        4       F\  pVP(                  P*                  '       d   \,        hVP(                  P.                  '       g   KC  WC! VP0                  W4      ,          pK^  	  V P%                  \2        \4        \6        4       F#  pWC! VP8                  ^ ,          W4      ,          pK%  	  V P%                  \:        \<        4       FQ  pWC! VP8                  ^ ,          ^,
          W4      ,          pWC! VP8                  ^ ,          ^,           W4      ,          pKS  	  V#   \,         d    \-        \?        R4      4      hi ; i)a  
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}

solvesetzl
            Methods for determining the singularities
            of this function have not been developed.) sympy.solvers.solvesetr   is_realr   Reals	ComplexesEmptySetrewriter   r   r	   r
   r   r   r   r   r   r   atomsr   expis_infiniteNotImplementedErroris_negativebaser   r   r   argsr   r   r   )
expressionsymboldomainr   singseis   &&&    |/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/sympy/calculus/singularities.pysingularitiesr-      sg   x 0~"NNN;

S#s3S9IItT4.5Auu   ))uu   !&&&99  !!#ue4AXaffQi88E 5!!%/AXaffQi!mV<<EXaffQi!mV<<E 0  ;!* .9 #: ; 	;;s   B7G :CG  G.c                T   ^ RI Hp \        V 4      p V P                  pVf   \	        V4      ^8  d   \        R4      hT;'       g$    V'       d   VP                  4       M
\        R4      pV P                  V4      pV! V! V4      V\        P                  4      pVP                  V4      # )a  
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.

r   zKThe function has not yet been implemented for all multivariate expressions.x)r   r   r   free_symbolslenr"   popr   diffr   r   	is_subset)	r&   	predicateintervalr'   r   freevariable
derivativepredicate_intervals	   &&&&     r,   monotonicity_helperr;   x   s    > 0$J""D~t9q=%5 
 >>$((*&+H*J!)J"7177K011    c                    \        V R W4      # )a  
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

c                     V ^ 8  #      r/   s   &r,   <lambda>is_increasing.<locals>.<lambda>       Q!Vr<   r;   r&   r6   r'   s   &&&r,   is_increasingrH      s    P z+;XNNr<   c                    \        V R W4      # )a  
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

c                     V ^ 8  # r?   rA   rB   s   &r,   rC   (is_strictly_increasing.<locals>.<lambda>       QUr<   rF   rG   s   &&&r,   is_strictly_increasingrM          P z?HMMr<   c                    \        V R W4      # )a>  
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

c                     V ^ 8*  # r?   rA   rB   s   &r,   rC   is_decreasing.<locals>.<lambda>+  rE   r<   rF   rG   s   &&&r,   is_decreasingrR      s    X z+;XNNr<   c                    \        V R W4      # )a  
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

c                     V ^ 8  # r?   rA   rB   s   &r,   rC   (is_strictly_decreasing.<locals>.<lambda>V  rL   r<   rF   rG   s   &&&r,   is_strictly_decreasingrV   .  rN   r<   c                F   ^ RI Hp \        V 4      p V P                  pVf   \	        V4      ^8  d   \        R4      hT;'       g$    V'       d   VP                  4       M
\        R4      pV! V P                  V4      WQ4      pVP                  V4      \        P                  J # )a  
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

r   zKis_monotonic has not yet been implemented for all multivariate expressions.r/   )r   r   r   r0   r1   r"   r2   r   r3   intersectionr   r   )r&   r6   r'   r   r7   r8   turning_pointss   &&&    r,   is_monotonicrZ   Y  s    ` 0$J""D~#d)a-!1
 	

 >>$((*&+Hjooh7LN  0AJJ>>r<   )N)%__doc__sympy.core.powerr   sympy.core.singletonr   sympy.core.symbolr   sympy.core.sympifyr   &sympy.functions.elementary.exponentialr   (sympy.functions.elementary.trigonometricr   r   r	   r
   r   %sympy.functions.elementary.hyperbolicr   r   r   r   r   r   r   r   r   sympy.utilities.miscr   r-   r   r;   rH   rM   rR   rV   rZ   rA   r<   r,   <module>rd      s   " ! " $ & 6 L L> > > +S;v 9: .2b ()wwt (OV 12 (NV ()wwt ,O^ 12 (NV '(ggd =?r<   