K i9 dZddlmZddlZddlmZddlmZddlm Z m Z m Z ddl m Z mZddlmZdd lmZdd lmZGd d eZeZGd de ZGddeZGdde eZGddeZedZy)z>> from sympy import ask, Q >>> from sympy.assumptions import global_assumptions >>> global_assumptions AssumptionsContext() You can add default assumptions: >>> from sympy.abc import x >>> global_assumptions.add(Q.real(x)) >>> global_assumptions AssumptionsContext({Q.real(x)}) >>> ask(Q.real(x)) True And remove them: >>> global_assumptions.remove(Q.real(x)) >>> print(ask(Q.real(x))) None The ``clear()`` method removes every assumption: >>> global_assumptions.add(Q.positive(x)) >>> global_assumptions AssumptionsContext({Q.positive(x)}) >>> global_assumptions.clear() >>> global_assumptions AssumptionsContext() See Also ======== assuming c2|D]}t||y)zAdd assumptions.N)superadd)self assumptionsa __class__s ^/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/sympy/assumptions/assume.pyrzAssumptionsContext.addCs A GKN c|sd|jjzSdj|jj|j|S)Nz%s()z{}({}))r__name__format _print_set)rprinters r _sympystrzAssumptionsContext._sympystrHs@DNN333 3t~~668J8J48PQQr)r __module__ __qualname____doc__rr __classcell__rs@rrrs2h RrrcleZdZdZdZfdZedZedZedZ dZ edZ xZ S) AppliedPredicatea The class of expressions resulting from applying ``Predicate`` to the arguments. ``AppliedPredicate`` merely wraps its argument and remain unevaluated. To evaluate it, use the ``ask()`` function. Examples ======== >>> from sympy import Q, ask >>> Q.integer(1) Q.integer(1) The ``function`` attribute returns the predicate, and the ``arguments`` attribute returns the tuple of arguments. >>> type(Q.integer(1)) >>> Q.integer(1).function Q.integer >>> Q.integer(1).arguments (1,) Applied predicates can be evaluated to a boolean value with ``ask``: >>> ask(Q.integer(1)) True ct|tstd|ztt|}t |||g|S)Nz%s is not a Predicate.) isinstance Predicate TypeErrormaprr__new__)cls predicateargsrs rr,zAppliedPredicate.__new__os@)Y/4y@A A8T"wsI555rcV|j}t|dk(r|dStd)z Return the expression used by this assumption. Examples ======== >>> from sympy import Q, Symbol >>> x = Symbol('x') >>> a = Q.integer(x + 1) >>> a.arg x + 1 z4'arg' property is allowed only for unary predicates.)_argslenr*rr/s rargzAppliedPredicate.argus- zz t9>7NNOOrc |jdS)z' Return the predicate. rr3rs rfunctionzAppliedPredicate.functions zz!}rc |jddS)zJ Return the arguments which are applied to the predicate. r2Nr8r9s r argumentszAppliedPredicate.argumentss zz!"~rcN|jj|j|SN)r:evalr<rrs r _eval_askzAppliedPredicate._eval_asks}}!!$..+>>rcddlm}|j|jk(r3|jd}|j s |j r |jS|j|j|jfvrvt|jvst|jvrR|jdj r|jdhS|jdj r|jdhStS)Nr2)Qr) askrCr:is_truer< is_Boolean is_Symbolbinary_symbolseqnerrset)rrCis rrHzAppliedPredicate.binary_symbolss ==AII %q!A||q{{''' ==QTT144L (t~~%$..)@>>!$.. NN1-..^^A&00 NN1-..u r) rrr r! __slots__r,propertyr6r:r<rArHr"r#s@rr%r%Psk8I6 PP*?  rr%c.eZdZfdZedZxZS) PredicateMetacd|vr)d|jd}t|d|z}||d<|jdd|d<t|||||S) NhandlerAskHandlerzHandler for key %s)docr! _orig_doc) capitalizer getrr,)r-clsnamebasesdctnamerRrs rr,zPredicateMeta.__new__sh C ++-.g6D +?$+FGG$C N779b1KwsGUC88rc|j}|j}|turN|K|dz }|dz }d|jzg}|jr6|jj D]}|s|j d|zg}|jdddD]}|j|}|jridt|z}g} |jj D]}| j d|z|dj| z }|j ||j t||r"d} |D] }| d |zz } |j | |d j|z }|S) NzHandler z ======= z" Multiply dispatched method: %sz %sz Inputs: <%s> z Other signatures:z * %sz ) rRrWr)r]rU splitlinesappendorderingfuncsr!r join) r-rRrUdocslineothersigfuncslinesothersigs rr!zPredicateMeta.__doc__sx++mm i G$7 ; C $ $C97<<GHD{{#KK2241D KK401E''"- 5}}S)<<*]3-??AE $ 7 7 96 X_565))AKKNLLs!34 52!8D 04 77H8 H% 6;;t$ $C r)rrr r,rNr!r"r#s@rrPrPs 9""rrPcjeZdZdZdZfdZedZedZ edZ dZ d dZ d Z xZS) r)aJ Base class for mathematical predicates. It also serves as a constructor for undefined predicate objects. Explanation =========== Predicate is a function that returns a boolean value [1]. Predicate function is object, and it is instance of predicate class. When a predicate is applied to arguments, ``AppliedPredicate`` instance is returned. This merely wraps the argument and remain unevaluated. To obtain the truth value of applied predicate, use the function ``ask``. Evaluation of predicate is done by multiple dispatching. You can register new handler to the predicate to support new types. Every predicate in SymPy can be accessed via the property of ``Q``. For example, ``Q.even`` returns the predicate which checks if the argument is even number. To define a predicate which can be evaluated, you must subclass this class, make an instance of it, and register it to ``Q``. After then, dispatch the handler by argument types. If you directly construct predicate using this class, you will get ``UndefinedPredicate`` which cannot be dispatched. This is useful when you are building boolean expressions which do not need to be evaluated. Examples ======== Applying and evaluating to boolean value: >>> from sympy import Q, ask >>> ask(Q.prime(7)) True You can define a new predicate by subclassing and dispatching. Here, we define a predicate for sexy primes [2] as an example. >>> from sympy import Predicate, Integer >>> class SexyPrimePredicate(Predicate): ... name = "sexyprime" >>> Q.sexyprime = SexyPrimePredicate() >>> @Q.sexyprime.register(Integer, Integer) ... def _(int1, int2, assumptions): ... args = sorted([int1, int2]) ... if not all(ask(Q.prime(a), assumptions) for a in args): ... return False ... return args[1] - args[0] == 6 >>> ask(Q.sexyprime(5, 11)) True Direct constructing returns ``UndefinedPredicate``, which can be applied but cannot be dispatched. >>> from sympy import Predicate, Integer >>> Q.P = Predicate("P") >>> type(Q.P) >>> Q.P(1) Q.P(1) >>> Q.P.register(Integer)(lambda expr, assump: True) Traceback (most recent call last): ... TypeError: cannot be dispatched. References ========== .. [1] https://en.wikipedia.org/wiki/Predicate_%28mathematical_logic%29 .. [2] https://en.wikipedia.org/wiki/Sexy_prime TcN|tur t|i|St| |g|}|Sr>)r)UndefinedPredicaterr,)r-r/kwargsobjrs rr,zPredicate.__new__1s3 ) %t6v6 6goc)D) rc,t|jSr>)typerr9s rr]zPredicate.name7sDz"""rc|jtdt|z|jj|i|S)z8 Register the signature to the handler. z%s cannot be dispatched.)rRr*rtregister)r-typesrqs rrvzPredicate.register<s? ;; 6cBC C#s{{##U5f55rcfd}|S)z? Register multiple signatures to same handler. c`D](}t|s|f}j|i|*yr>)r rv)rjtr-rqrws r_z"Predicate.register_many.._Js: 1"1~A*  a*6*40 1rr&)r-rwrqr{s``` r register_manyzPredicate.register_manyEs  1 rct|g|Sr>r%r5s r__call__zPredicate.__call__Qs,t,,rcPd} |j|d|i}|S#t$rY|SwxYw)z Evaluate ``self(*args)`` under the given assumptions. This uses only direct resolution methods, not logical inference. Nr)rRNotImplementedError)rr/rresults rr?zPredicate.evalTsC  !T\\4A[AF #    s  %%c|Sr>r&r@s r _eval_refinezPredicate._eval_refineas rT)rrr r!is_Atomr,rNr] classmethodrvr|rr?rr"r#s@rr)r)saL\G ##66  - rr)) metaclassc^eZdZdZdZd fd ZedZdZdZ dZ dZ d Z d d Z xZS) rpa Predicate without handler. Explanation =========== This predicate is generated by using ``Predicate`` directly for construction. It does not have a handler, and evaluating this with arguments is done by SAT solver. Examples ======== >>> from sympy import Predicate, Q >>> Q.P = Predicate('P') >>> Q.P.func >>> Q.P.name Str('P') Nc|t|ts t|}tt|||}|xsg|_|Sr>)r(rrrr,handlers)r-r]rrrrs rr,zUndefinedPredicate.__new__s9$$t9DGS)#t4~2  rc |jdS)Nr)r/r9s rr]zUndefinedPredicate.namesyy|rc|jfSr>r]r9s r_hashable_contentz$UndefinedPredicate._hashable_content |rc|jfSr>rr9s r__getnewargs__z!UndefinedPredicate.__getnewargs__rrct||Sr>r~)rexprs rrzUndefinedPredicate.__call__sd++rcVtddd|jj|y)Nz The AskHandler system is deprecated. Predicate.add_handler() should be replaced with the multipledispatch handler of Predicate. 1.8deprecated-askhandlerdeprecated_since_versionactive_deprecations_target)r rrbrrRs r add_handlerzUndefinedPredicate.add_handler+! &+'>   W%rcVtddd|jj|y)Nz The AskHandler system is deprecated. Predicate.remove_handler() should be replaced with the multipledispatch handler of Predicate. rrr)r rremovers rremove_handlerz!UndefinedPredicate.remove_handlerrrc0tdddd|\}d\}}tjt|}|jD]P}t |}|D]>} t || jd} | | ||}|)||}n||k7r tdPR|S)Nz The AskHandler system is deprecated. Evaluating UndefinedPredicate objects should be replaced with the multipledispatch handler of Predicate. rr)rr stacklevel)NNzincompatible resolutors) r inspectgetmrortrr getattrr ValueError) rr/rrres_resmrorRr-subclasseval_s rr?zUndefinedPredicate.evals "  &+'>  TnnT$Z(}} GG$C X%6%6==D+.;<Ds{()BCC  $ rr>r)rrr r!rRr,rNr]rrrrrr?r"r#s@rrprpfsF,G, & &"rrpc'Ktj}tj| dtjtj|y#tjtj|wxYww)a' Context manager for assumptions. Examples ======== >>> from sympy import assuming, Q, ask >>> from sympy.abc import x, y >>> print(ask(Q.integer(x + y))) None >>> with assuming(Q.integer(x), Q.integer(y)): ... print(ask(Q.integer(x + y))) True N)global_assumptionscopyupdateclear)rold_global_assumptionss rassumingrsf 0446k*:   "!!"89   "!!"89s*B A*B +BB )r! contextlibrrsympy.core.symbolrsympy.core.sympifyrsympy.logic.boolalgrrr!sympy.multipledispatch.dispatcherr r sympy.utilities.exceptionsr sympy.utilities.iterablesr sympy.utilities.sourcer rKrrr%rtrPr)rprr&rrrsB%!'44G@1,=R=R~()[w[|/D/dC=CLffR::r