a RG5dI@sdZddlmZmZmZddlmZmZmZddl m Z ddl m Z ddl mZmZmZmZmZmZddlmZddlmZdd lmZmZmZGd d d ZeZd d ZdefddZddZ ddZ!ddZ"ddl#m$Z$m%Z%dS)z4Module for querying SymPy objects about assumptions.)global_assumptions PredicateAppliedPredicate)CNF EncodedCNFLiteral)sympify) BooleanKind)EqNeGtLtGeLe) satisfiable)memoize_property)sympy_deprecation_warningSymPyDeprecationWarningignore_warningsc@seZdZdZeddZeddZeddZedd Zed d Z ed d Z eddZ eddZ eddZ eddZeddZeddZeddZeddZeddZed d!Zed"d#Zed$d%Zed&d'Zed(d)Zed*d+Zed,d-Zed.d/Zed0d1Zed2d3Zed4d5Zed6d7Zed8d9Z ed:d;Z!edd?Z#ed@dAZ$edBdCZ%edDdEZ&edFdGZ'edHdIZ(edJdKZ)edLdMZ*edNdOZ+edPdQZ,edRdSZ-edTdUZ.edVdWZ/edXdYZ0edZd[Z1ed\d]Z2ed^d_Z3ed`daZ4edbdcZ5edddeZ6edfdgZ7edhdiZ8edjdkZ9edldmZ:edndoZ;dpS)qAssumptionKeyszy This class contains all the supported keys by ``ask``. It should be accessed via the instance ``sympy.Q``. cCsddlm}|S)N)HermitianPredicate) handlers.setsr)selfrrQ/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/assumptions/ask.py hermitian s zAssumptionKeys.hermitiancCsddlm}|S)Nr)AntihermitianPredicate)rr)rrrrr antihermitian%s zAssumptionKeys.antihermitiancCsddlm}|S)Nr) RealPredicate)rr)rrrrrreal*s zAssumptionKeys.realcCsddlm}|S)Nr)ExtendedRealPredicate)rr!)rr!rrr extended_real/s zAssumptionKeys.extended_realcCsddlm}|S)Nr)ImaginaryPredicate)rr#)rr#rrr imaginary4s zAssumptionKeys.imaginarycCsddlm}|S)Nr)ComplexPredicate)rr%)rr%rrrcomplex9s zAssumptionKeys.complexcCsddlm}|S)Nr)AlgebraicPredicate)rr')rr'rrr algebraic>s zAssumptionKeys.algebraiccCsddlm}|S)Nr)TranscendentalPredicate)Zpredicates.setsr))rr)rrrtranscendentalCs zAssumptionKeys.transcendentalcCsddlm}|S)Nr)IntegerPredicate)rr+)rr+rrrintegerHs zAssumptionKeys.integercCsddlm}|S)Nr)RationalPredicate)rr-)rr-rrrrationalMs zAssumptionKeys.rationalcCsddlm}|S)Nr)IrrationalPredicate)rr/)rr/rrr irrationalRs zAssumptionKeys.irrationalcCsddlm}|S)Nr)FinitePredicate)handlers.calculusr1)rr1rrrfiniteWs zAssumptionKeys.finitecCsddlm}|S)Nr)InfinitePredicate)r2r4)rr4rrrinfinite\s zAssumptionKeys.infinitecCsddlm}|S)Nr)PositiveInfinitePredicate)r2r6)rr6rrrpositive_infiniteas z AssumptionKeys.positive_infinitecCsddlm}|S)Nr)NegativeInfinitePredicate)r2r8)rr8rrrnegative_infinitefs z AssumptionKeys.negative_infinitecCsddlm}|S)Nr)PositivePredicate)handlers.orderr:)rr:rrrpositiveks zAssumptionKeys.positivecCsddlm}|S)Nr)NegativePredicate)r;r=)rr=rrrnegativeps zAssumptionKeys.negativecCsddlm}|S)Nr) ZeroPredicate)r;r?)rr?rrrzerous zAssumptionKeys.zerocCsddlm}|S)Nr)ExtendedPositivePredicate)r;rA)rrArrrextended_positivezs z AssumptionKeys.extended_positivecCsddlm}|S)Nr)ExtendedNegativePredicate)r;rC)rrCrrrextended_negatives z AssumptionKeys.extended_negativecCsddlm}|S)Nr)NonZeroPredicate)r;rE)rrErrrnonzeros zAssumptionKeys.nonzerocCsddlm}|S)Nr)NonPositivePredicate)r;rG)rrGrrr nonpositives zAssumptionKeys.nonpositivecCsddlm}|S)Nr)NonNegativePredicate)r;rI)rrIrrr nonnegatives zAssumptionKeys.nonnegativecCsddlm}|S)Nr)ExtendedNonZeroPredicate)r;rK)rrKrrrextended_nonzeros zAssumptionKeys.extended_nonzerocCsddlm}|S)Nr)ExtendedNonPositivePredicate)r;rM)rrMrrrextended_nonpositives z#AssumptionKeys.extended_nonpositivecCsddlm}|S)Nr)ExtendedNonNegativePredicate)r;rO)rrOrrrextended_nonnegatives z#AssumptionKeys.extended_nonnegativecCsddlm}|S)Nr) EvenPredicate)handlers.ntheoryrQ)rrQrrrevens zAssumptionKeys.evencCsddlm}|S)Nr) OddPredicate)rRrT)rrTrrrodds zAssumptionKeys.oddcCsddlm}|S)Nr)PrimePredicate)rRrV)rrVrrrprimes zAssumptionKeys.primecCsddlm}|S)Nr)CompositePredicate)rRrX)rrXrrr composites zAssumptionKeys.compositecCsddlm}|S)Nr)CommutativePredicate)handlers.commonrZ)rrZrrr commutatives zAssumptionKeys.commutativecCsddlm}|S)Nr)IsTruePredicate)r[r])rr]rrris_trues zAssumptionKeys.is_truecCsddlm}|S)Nr)SymmetricPredicate)handlers.matricesr_)rr_rrr symmetrics zAssumptionKeys.symmetriccCsddlm}|S)Nr)InvertiblePredicate)r`rb)rrbrrr invertibles zAssumptionKeys.invertiblecCsddlm}|S)Nr)OrthogonalPredicate)r`rd)rrdrrr orthogonals zAssumptionKeys.orthogonalcCsddlm}|S)Nr)UnitaryPredicate)r`rf)rrfrrrunitarys zAssumptionKeys.unitarycCsddlm}|S)Nr)PositiveDefinitePredicate)r`rh)rrhrrrpositive_definites z AssumptionKeys.positive_definitecCsddlm}|S)Nr)UpperTriangularPredicate)r`rj)rrjrrrupper_triangulars zAssumptionKeys.upper_triangularcCsddlm}|S)Nr)LowerTriangularPredicate)r`rl)rrlrrrlower_triangulars zAssumptionKeys.lower_triangularcCsddlm}|S)Nr)DiagonalPredicate)r`rn)rrnrrrdiagonals zAssumptionKeys.diagonalcCsddlm}|S)Nr)FullRankPredicate)r`rp)rrprrrfullranks zAssumptionKeys.fullrankcCsddlm}|S)Nr)SquarePredicate)r`rr)rrrrrrsquares zAssumptionKeys.squarecCsddlm}|S)Nr)IntegerElementsPredicate)r`rt)rrtrrrinteger_elementss zAssumptionKeys.integer_elementscCsddlm}|S)Nr)RealElementsPredicate)r`rv)rrvrrr real_elementss zAssumptionKeys.real_elementscCsddlm}|S)Nr)ComplexElementsPredicate)r`rx)rrxrrrcomplex_elementss zAssumptionKeys.complex_elementscCsddlm}|S)Nr)SingularPredicate)predicates.matricesrz)rrzrrrsingulars zAssumptionKeys.singularcCsddlm}|S)Nr)NormalPredicate)r{r})rr}rrrnormals zAssumptionKeys.normalcCsddlm}|S)Nr)TriangularPredicate)r{r)rrrrr triangular s zAssumptionKeys.triangularcCsddlm}|S)Nr)UnitTriangularPredicate)r{r)rrrrrunit_triangulars zAssumptionKeys.unit_triangularcCsddlm}|S)Nr)EqualityPredicate)relation.equalityr)rrrrreqs zAssumptionKeys.eqcCsddlm}|S)Nr)UnequalityPredicate)rr)rrrrrnes zAssumptionKeys.necCsddlm}|S)Nr)StrictGreaterThanPredicate)rr)rrrrrgts zAssumptionKeys.gtcCsddlm}|S)Nr)GreaterThanPredicate)rr)rrrrrge$s zAssumptionKeys.gecCsddlm}|S)Nr)StrictLessThanPredicate)rr)rrrrrlt)s zAssumptionKeys.ltcCsddlm}|S)Nr)LessThanPredicate)rr)rrrrrle.s zAssumptionKeys.leN)<__name__ __module__ __qualname____doc__rrrr r"r$r&r(r*r,r.r0r3r5r7r9r<r>r@rBrDrFrHrJrLrNrPrSrUrWrYr\r^rarcrergrirkrmrorqrsrurwryr|r~rrrrrrrrrrrrrs                                                       rcCs~t}|jD]h}g}|D]H}t|jtrt|jjdkr|jj|vr\|t |jj |j qq q|r | t |q t|S)a Extract all relevant assumptions from *assump* with respect to given *exprs*. Parameters ========== assump : sympy.assumptions.cnf.CNF exprs : tuple of expressions Returns ======= sympy.assumptions.cnf.CNF Examples ======== >>> from sympy import Q >>> from sympy.assumptions.cnf import CNF >>> from sympy.assumptions.ask import _extract_all_facts >>> from sympy.abc import x, y >>> assump = CNF.from_prop(Q.positive(x) & Q.integer(y)) >>> exprs = (x,) >>> cnf = _extract_all_facts(assump, exprs) >>> cnf.clauses {frozenset({Literal(Q.positive, False)})} r)setclauses isinstancelitrlen argumentsargappendrfunctionis_Notadd frozensetr)Zassumpexprsfactsclauseargsliteralrrr_extract_all_facts6s  rTc Csrddlm}t|}t|}t|ts0|jtur8tdt|tsL|jturTtdtt j t t j t t jtt jtt jtt ji}t|tr|j|j}}n.|j|vr|t||j}}nt j|f}}t|}||t||}t } t!} | "t| | #||j$r(t%| dur(t&d|t'||} | dur@| S||(|} | dur`t)| S||||d} | S) a Function to evaluate the proposition with assumptions. Explanation =========== This function evaluates the proposition to ``True`` or ``False`` if the truth value can be determined. If not, it returns ``None``. It should be discerned from :func:`~.refine()` which, when applied to a proposition, simplifies the argument to symbolic ``Boolean`` instead of Python built-in ``True``, ``False`` or ``None``. **Syntax** * ask(proposition) Evaluate the *proposition* in global assumption context. * ask(proposition, assumptions) Evaluate the *proposition* with respect to *assumptions* in global assumption context. Parameters ========== proposition : Any boolean expression. Proposition which will be evaluated to boolean value. If this is not ``AppliedPredicate``, it will be wrapped by ``Q.is_true``. assumptions : Any boolean expression, optional. Local assumptions to evaluate the *proposition*. context : AssumptionsContext, optional. Default assumptions to evaluate the *proposition*. By default, this is ``sympy.assumptions.global_assumptions`` variable. Returns ======= ``True``, ``False``, or ``None`` Raises ====== TypeError : *proposition* or *assumptions* is not valid logical expression. ValueError : assumptions are inconsistent. Examples ======== >>> from sympy import ask, Q, pi >>> from sympy.abc import x, y >>> ask(Q.rational(pi)) False >>> ask(Q.even(x*y), Q.even(x) & Q.integer(y)) True >>> ask(Q.prime(4*x), Q.integer(x)) False If the truth value cannot be determined, ``None`` will be returned. >>> print(ask(Q.odd(3*x))) # cannot determine unless we know x None ``ValueError`` is raised if assumptions are inconsistent. >>> ask(Q.integer(x), Q.even(x) & Q.odd(x)) Traceback (most recent call last): ... ValueError: inconsistent assumptions Q.even(x) & Q.odd(x) Notes ===== Relations in assumptions are not implemented (yet), so the following will not give a meaningful result. >>> ask(Q.positive(x), x > 0) It is however a work in progress. See Also ======== sympy.assumptions.refine.refine : Simplification using assumptions. Proposition is not reduced to ``None`` if the truth value cannot be determined. r)sataskz.proposition must be a valid logical expressionz.assumptions must be a valid logical expressionFzinconsistent assumptions %sN) assumptionscontext)*Zsympy.assumptions.sataskrrrrkindr TypeErrorr Qrr rr rr rrrrrrrrfunctyperr^rZ from_propextendrget_all_known_factsrZfrom_cnfZ add_from_cnfrr ValueError_ask_single_fact _eval_askbool) Z propositionrrrZ binrelpredskeyrZ assump_cnf local_factsZknown_facts_cnfZenc_cnfresrrraskfs<Z (          rc Cs|jrt}t|jdkrj|j\}t|dkrj|\}||d}|durP|dnt}|jrj|j|vrjdS|jD]\}t|dkrp|\}|js||jdnd}|durqp|\}}||vrdS||vrpdSqpdS)a Compute the truth value of single predicate using assumptions. Parameters ========== key : sympy.assumptions.assume.Predicate Proposition predicate. local_facts : sympy.assumptions.cnf.CNF Local assumption in CNF form. Returns ======= ``True``, ``False`` or ``None`` Examples ======== >>> from sympy import Q >>> from sympy.assumptions.cnf import CNF >>> from sympy.assumptions.ask import _ask_single_fact If prerequisite of proposition is rejected by the assumption, return ``False``. >>> key, assump = Q.zero, ~Q.zero >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) False >>> key, assump = Q.zero, ~Q.even >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) False If assumption implies the proposition, return ``True``. >>> key, assump = Q.even, Q.zero >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) True If proposition rejects the assumption, return ``False``. >>> key, assump = Q.even, Q.odd >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) False rNrFT)rget_known_facts_dictrgetrrr) rrZknown_facts_dictclfZ prop_factsZprop_reqrZprop_rejrrrrs,3    rcCsZtddddt|tr |jj}tt|d}|dur@||ntt|t||gddS)z Register a handler in the ask system. key must be a string and handler a class inheriting from AskHandler. .. deprecated:: 1.8. Use multipledispatch handler instead. See :obj:`~.Predicate`. z The AskHandler system is deprecated. The register_handler() function should be replaced with the multipledispatch handler of Predicate. 1.8deprecated-askhandlerdeprecated_since_versionactive_deprecations_targetN)handlers)rrrnamegetattrr add_handlersetattr)rhandlerZQkeyrrrregister_handlerFs    rcCs\tddddt|tr |jj}tt tt||Wdn1sN0YdS)z Removes a handler from the ask system. Same syntax as register_handler .. deprecated:: 1.8. Use multipledispatch handler instead. See :obj:`~.Predicate`. z The AskHandler system is deprecated. The remove_handler() function should be replaced with the multipledispatch handler of Predicate. rrrN) rrrrrrrrremove_handler)rrrrrr`s  r)rrN)&rZsympy.assumptions.assumerrrZsympy.assumptions.cnfrrr sympy.corerZsympy.core.kindr sympy.core.relationalr r r r rrsympy.logic.inferencersympy.utilities.decoratorrsympy.utilities.exceptionsrrrrrrrrrrZsympy.assumptions.ask_generatedrrrrrrs&      !0S