o jg9@sdZddlmZddlZddlmZddlmZddlm Z m Z m Z ddl m Z mZddlmZdd lmZdd lmZGd d d eZeZGd dde ZGdddeZGddde edZGdddeZeddZdS)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 cs|D]}t|qdS)zAdd assumptions.N)superadd)self assumptionsa __class__P/var/www/html/zoom/venv/lib/python3.10/site-packages/sympy/assumptions/assume.pyrCszAssumptionsContext.addcCs&|sd|jjSd|jj||S)Nz%s()z{}({}))r__name__format _print_set)rprinterrrr _sympystrHs zAssumptionsContext._sympystr)r __module__ __qualname____doc__rr __classcell__rrrrr s 4r cs\eZdZdZdZfddZeddZeddZed d Z d d Z ed dZ Z 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 rcs6t|ts td|tt|}tj||g|RS)Nz%s is not a Predicate.) isinstance Predicate TypeErrormaprr__new__)cls predicateargsrrrr%os   zAppliedPredicate.__new__cCs"|j}t|dkr |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(rrrargus zAppliedPredicate.argcC |jdS)z' Return the predicate. rr+rrrrfunctions zAppliedPredicate.functioncCs|jddS)zJ Return the arguments which are applied to the predicate. r*Nr0r1rrr argumentsszAppliedPredicate.argumentscCs|j|j|SN)r2evalr3rrrrr _eval_askzAppliedPredicate._eval_askcCsddlm}|j|jkr|jd}|js|jr|jS|j|j|j fvrEt |jvs-t |jvrE|jdjr9|jdhS|jdjrE|jdhSt S)Nr*)Qr) askr9r2is_truer3 is_Boolean is_Symbolbinary_symbolseqnerrset)rr9irrrr>s        zAppliedPredicate.binary_symbols) rrrr __slots__r%propertyr.r2r3r7r>rrrrrr Ps    r cs(eZdZfddZeddZZS) PredicateMetacsRd|vrd|d}t|d|d}||d<|dd|d<t||||S) NhandlerAskHandlerzHandler for key %s)docr _orig_doc) capitalizergetrr%)r&clsnamebasesdctnamerFrrrr%s zPredicateMeta.__new__c Cs|j}|j}|tur|dur|d7}|d7}d|jg}|jr1|jD] }|s)q$|d|q$g}|jdddD]5}|j|}|j ridt |}g} |j D] }| d|qR|d | 7}||q;|t |q;|rd} |D]}| d |7} qw|| |d |7}|S) NzHandler z ======= z" Multiply dispatched method: %sz %sz Inputs: <%s> z Other signatures:z * %sz ) rFrKr"rQrI splitlinesappendorderingfuncsrr join) r&rFrIdocslineothersigfuncslinesothersigrrrrs:     zPredicateMeta.__doc__)rrrr%rDrrrrrrrEs  rEcsbeZdZdZdZfddZeddZeddZ ed d Z d d Z dd dZ ddZ ZS)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 Tcs.|tur t|i|Stj|g|R}|Sr4)r"UndefinedPredicaterr%)r&r(kwargsobjrrrr%1szPredicate.__new__cCs t|jSr4)typerr1rrrrQ7s zPredicate.namecOs,|jdur tdt||jj|i|S)z8 Register the signature to the handler. Nz%s cannot be dispatched.)rFr#rdregister)r&typesrbrrrre<s zPredicate.registercsfdd}|S)z? Register multiple signatures to same handler. cs0D]}t|s |f}j|i|qdSr4)r re)r]tr&rbrfrr_Js z"Predicate.register_many.._r)r&rfrbrirrhr register_manyEszPredicate.register_manycGst|g|RSr4r r-rrr__call__Qr8zPredicate.__call__cCs0d}z |j|d|i}W|StyY|Sw)z Evaluate ``self(*args)`` under the given assumptions. This uses only direct resolution methods, not logical inference. Nr)rFNotImplementedError)rr(rresultrrrr5Ts zPredicate.evalcCs|Sr4rr6rrr _eval_refineaszPredicate._eval_refineT)rrrris_Atomr%rDrQ classmethodrerjrlr5rorrrrrr"sN      r") metaclasscsdeZdZdZdZdfdd ZeddZddZd d Z d d Z d dZ ddZ dddZ ZS)raa 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') Ncs2t|ts t|}tt|||}|pg|_|Sr4)r!rrrr%handlers)r&rQrtrcrrrr%s  zUndefinedPredicate.__new__cCr/)Nr)r(r1rrrrQs zUndefinedPredicate.namecC|jfSr4rQr1rrr_hashable_contentz$UndefinedPredicate._hashable_contentcCrur4rvr1rrr__getnewargs__rxz!UndefinedPredicate.__getnewargs__cCs t||Sr4rk)rexprrrrrls zUndefinedPredicate.__call__cCtdddd|j|dS)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 rtrUrrFrrr add_handler zUndefinedPredicate.add_handlercCr{)Nz The AskHandler system is deprecated. Predicate.remove_handler() should be replaced with the multipledispatch handler of Predicate. r|r}r~)r rtremoverrrrremove_handlerrz!UndefinedPredicate.remove_handlerTc Cstddddd|\}d\}}tt|}|jD]0}t|}|D]'} t|| jd} | dur/q!| ||}|dur9q!|dur@|}n||krHtdq|S)Nz The AskHandler system is deprecated. Evaluating UndefinedPredicate objects should be replaced with the multipledispatch handler of Predicate. r|r})rr stacklevel)NNzincompatible resolutors) r inspectgetmrordrtr getattrr ValueError) rr(rrzres_resmrorFr&subclasseval_rrrr5s2   zUndefinedPredicate.evalr4rp)rrrrrFr%rDrQrwryrlrrr5rrrrrrafs   rac gsHt}t|zdVWtt|dStt|w)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_assumptionsrrrassumings  r)r contextlibrrsympy.core.symbolrsympy.core.sympifyrsympy.logic.boolalgrrr!sympy.multipledispatch.dispatcherrr sympy.utilities.exceptionsr sympy.utilities.iterablesr sympy.utilities.sourcer rAr rr rdrEr"rarrrrrs&      ?^2i