o jgK@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;edpdqZrzAssumptionKeys.algebraiccCr)Nr)TranscendentalPredicate)predicates.setsr+)rr+rrrtranscendentalCrzAssumptionKeys.transcendentalcCr)Nr)IntegerPredicate)rr.)rr.rrrintegerHrzAssumptionKeys.integercCr)Nr)NonIntegerPredicate)r,r0)rr0rrr nonintegerMrzAssumptionKeys.nonintegercCr)Nr)RationalPredicate)rr2)rr2rrrrationalRrzAssumptionKeys.rationalcCr)Nr)IrrationalPredicate)rr4)rr4rrr irrationalWrzAssumptionKeys.irrationalcCr)Nr)FinitePredicate)handlers.calculusr6)rr6rrrfinite\rzAssumptionKeys.finitecCr)Nr)InfinitePredicate)r7r9)rr9rrrinfinitearzAssumptionKeys.infinitecCr)Nr)PositiveInfinitePredicate)r7r;)rr;rrrpositive_infinitefrz AssumptionKeys.positive_infinitecCr)Nr)NegativeInfinitePredicate)r7r=)rr=rrrnegative_infinitekrz AssumptionKeys.negative_infinitecCr)Nr)PositivePredicate)handlers.orderr?)rr?rrrpositiveprzAssumptionKeys.positivecCr)Nr)NegativePredicate)r@rB)rrBrrrnegativeurzAssumptionKeys.negativecCr)Nr) ZeroPredicate)r@rD)rrDrrrzerozrzAssumptionKeys.zerocCr)Nr)ExtendedPositivePredicate)r@rF)rrFrrrextended_positiverz AssumptionKeys.extended_positivecCr)Nr)ExtendedNegativePredicate)r@rH)rrHrrrextended_negativerz AssumptionKeys.extended_negativecCr)Nr)NonZeroPredicate)r@rJ)rrJrrrnonzerorzAssumptionKeys.nonzerocCr)Nr)NonPositivePredicate)r@rL)rrLrrr nonpositiverzAssumptionKeys.nonpositivecCr)Nr)NonNegativePredicate)r@rN)rrNrrr nonnegativerzAssumptionKeys.nonnegativecCr)Nr)ExtendedNonZeroPredicate)r@rP)rrPrrrextended_nonzerorzAssumptionKeys.extended_nonzerocCr)Nr)ExtendedNonPositivePredicate)r@rR)rrRrrrextended_nonpositiverz#AssumptionKeys.extended_nonpositivecCr)Nr)ExtendedNonNegativePredicate)r@rT)rrTrrrextended_nonnegativerz#AssumptionKeys.extended_nonnegativecCr)Nr) EvenPredicate)handlers.ntheoryrV)rrVrrrevenrzAssumptionKeys.evencCr)Nr) OddPredicate)rWrY)rrYrrroddrzAssumptionKeys.oddcCr)Nr)PrimePredicate)rWr[)rr[rrrprimerzAssumptionKeys.primecCr)Nr)CompositePredicate)rWr])rr]rrr compositerzAssumptionKeys.compositecCr)Nr)CommutativePredicate)handlers.commonr_)rr_rrr commutativerzAssumptionKeys.commutativecCr)Nr)IsTruePredicate)r`rb)rrbrrris_truerzAssumptionKeys.is_truecCr)Nr)SymmetricPredicate)handlers.matricesrd)rrdrrr symmetricrzAssumptionKeys.symmetriccCr)Nr)InvertiblePredicate)rerg)rrgrrr invertiblerzAssumptionKeys.invertiblecCr)Nr)OrthogonalPredicate)reri)rrirrr orthogonalrzAssumptionKeys.orthogonalcCr)Nr)UnitaryPredicate)rerk)rrkrrrunitaryrzAssumptionKeys.unitarycCr)Nr)PositiveDefinitePredicate)rerm)rrmrrrpositive_definiterz AssumptionKeys.positive_definitecCr)Nr)UpperTriangularPredicate)rero)rrorrrupper_triangularrzAssumptionKeys.upper_triangularcCr)Nr)LowerTriangularPredicate)rerq)rrqrrrlower_triangularrzAssumptionKeys.lower_triangularcCr)Nr)DiagonalPredicate)rers)rrsrrrdiagonalrzAssumptionKeys.diagonalcCr)Nr)FullRankPredicate)reru)rrurrrfullrankrzAssumptionKeys.fullrankcCr)Nr)SquarePredicate)rerw)rrwrrrsquarerzAssumptionKeys.squarecCr)Nr)IntegerElementsPredicate)rery)rryrrrinteger_elementsrzAssumptionKeys.integer_elementscCr)Nr)RealElementsPredicate)rer{)rr{rrr real_elementsrzAssumptionKeys.real_elementscCr)Nr)ComplexElementsPredicate)rer})rr}rrrcomplex_elementsrzAssumptionKeys.complex_elementscCr)Nr)SingularPredicate)predicates.matricesr)rrrrrsingularrzAssumptionKeys.singularcCr)Nr)NormalPredicate)rr)rrrrrnormal rzAssumptionKeys.normalcCr)Nr)TriangularPredicate)rr)rrrrr triangularrzAssumptionKeys.triangularcCr)Nr)UnitTriangularPredicate)rr)rrrrrunit_triangularrzAssumptionKeys.unit_triangularcCr)Nr)EqualityPredicate)relation.equalityr)rrrrreqrzAssumptionKeys.eqcCr)Nr)UnequalityPredicate)rr)rrrrrnerzAssumptionKeys.necCr)Nr)StrictGreaterThanPredicate)rr)rrrrrgt$rzAssumptionKeys.gtcCr)Nr)GreaterThanPredicate)rr)rrrrrge)rzAssumptionKeys.gecCr)Nr)StrictLessThanPredicate)rr)rrrrrlt.rzAssumptionKeys.ltcCr)Nr)LessThanPredicate)rr)rrrrrle3rzAssumptionKeys.leN)=__name__ __module__ __qualname____doc__rrr r"r$r&r(r*r-r/r1r3r5r8r:r<r>rArCrErGrIrKrMrOrQrSrUrXrZr\r^rarcrfrhrjrlrnrprrrtrvrxrzr|r~rrrrrrrrrrrrrrrs                                                       rcCst}|jD]5}g}|D]%}t|jtr0t|jjdkr0|jj|vr.|t |jj |j q n n |r;| t |qt|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)assumpexprsfactsclauseargsliteralrrr_extract_all_facts;s  rTc Csddlm}ddlm}ddlm}t|}t|}t|ts$|j t ur(t dt|ts2|j t ur6t dt t jtt jtt jtt jtt jtt ji}t|trW|j|j}}n|j|vrg|t||j}}nt j|f}}t !|} | "|t#| |} t$} t%} | &t | | '| | j(rt)| durt*d|t+|| } | d ur| S||,|} | d urt-| S||||d } | d ur| Sz ||||d } W| S|yYd Sw) ay 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 : Boolean Proposition which will be evaluated to boolean value. If this is not ``AppliedPredicate``, it will be wrapped by ``Q.is_true``. assumptions : Boolean, 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)satask) lra_satask)UnhandledInputz.proposition must be a valid logical expressionz.assumptions must be a valid logical expressionFzinconsistent assumptions %sN) assumptionscontext).sympy.assumptions.sataskrsympy.assumptions.lra_sataskr!sympy.logic.algorithms.lra_theoryrrrrkindr TypeErrorr Qrr rr rr rrrrrrrrfunctyperrcr from_propextendrget_all_known_factsrfrom_cnf add_from_cnfrr ValueError_ask_single_fact _eval_askbool) propositionrrrrr binrelpredskeyr assump_cnf local_factsknown_facts_cnfenc_cnfresrrraskosN Z  (         rc Cs|jrgt}t|jdkr5|j\}t|dkr5|\}||d}|dur(|dnt}|jr5|j|vr5dS|jD].}t|dkrf|\}|jsM||jdnd}|durTq8|\}}||vr_dS||vrfdSq8dS)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) rrknown_facts_dictclf prop_factsprop_reqrprop_rejrrrrs.3    rcCs\tddddt|tr|jj}tt|d}|dur!||dStt|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)rhandlerQkeyrrrregister_handlerYs   rcCs^tddddt|tr|jj}tttt||WddS1s(wYdS)z Removes a handler from the ask system. .. 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)rrrrrrss  "r)rrN)&rsympy.assumptions.assumerrrsympy.assumptions.cnfrrr sympy.corersympy.core.kindr sympy.core.relationalr r r r rrsympy.logic.inferencersympy.utilities.decoratorrsympy.utilities.exceptionsrrrrrrrrrrsympy.assumptions.ask_generatedrrrrrrs(      &4S