Otj-dZddlmZddlmZddlmZmZddlm Z m Z ddl m Z m Z ddlmZddlmZdd lmZdd lmZmZdd lmZd e d efd ZdZddZdZddZd efdZdS)zJ Module to evaluate the proposition with assumptions using SAT algorithm. )S)Symbol) NumberKind UndefinedKind)get_all_known_matrix_factsget_all_known_number_facts)global_assumptionsAppliedPredicate)class_fact_registry)oo) satisfiable)CNF EncodedCNF) MatrixKindTchtj|}tj|}tj|}t}|r||}t|||||}|||r||t |||S)a Function to evaluate the proposition with assumptions using SAT algorithm. This function extracts every fact relevant to the expressions composing proposition and assumptions. For example, if a predicate containing ``Abs(x)`` is proposed, then ``Q.zero(Abs(x)) | Q.positive(Abs(x))`` will be found and passed to SAT solver because ``Q.nonnegative`` is registered as a fact for ``Abs``. Proposition is evaluated to ``True`` or ``False`` if the truth value can be determined. If not, ``None`` is returned. Parameters ========== proposition : Any boolean expression. Proposition which will be evaluated to boolean value. 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. use_known_facts : bool, optional. If ``True``, facts from ``sympy.assumptions.ask_generated`` module are passed to SAT solver as well. iterations : int, optional. Number of times that relevant facts are recursively extracted. Default is infinite times until no new fact is found. Returns ======= ``True``, ``False``, or ``None`` Examples ======== >>> from sympy import Abs, Q >>> from sympy.assumptions.satask import satask >>> from sympy.abc import x >>> satask(Q.zero(Abs(x)), Q.zero(x)) True )use_known_facts iterations)r from_propextendget_all_relevant_facts add_from_cnfcheck_satisfiability) proposition assumptionscontextrrprops_props context_cnfsats V/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sympy/assumptions/satask.pysataskr!sd M+ & &E ]K< ( (F- ,,K%%K2!((11  ['J @ @ @C[!!!& %%% vs 3 33c4|}|}||||t|}t|}|r|rdS|r|sdS|s|rdS|s|stddSdS)NTFzInconsistent assumptions)copyrr ValueError)prop_propfactbasesat_true sat_false can_be_true can_be_falses r rrUs}}H I $ 5!!!h''Ky))L|t<t <u 5|53444 5555r"Nc t| |}t}|r||z}|r||z}|tjtjhz }d}|tkrXt}|D]+}t|}| ztkr||z},| z } |z |tkX| fd|Dz}t} |D]D} t | tr| t| jz} /| | E| S)a Extract every expression in the argument of predicates from *proposition*, *assumptions* and *context*. Parameters ========== proposition : sympy.assumptions.cnf.CNF assumptions : sympy.assumptions.cnf.CNF, optional. context : sympy.assumptions.cnf.CNF, optional. CNF generated from assumptions context. Examples ======== >>> from sympy import Q, Abs >>> from sympy.assumptions.cnf import CNF >>> from sympy.assumptions.satask import extract_predargs >>> from sympy.abc import x, y >>> props = CNF.from_prop(Q.zero(Abs(x*y))) >>> assump = CNF.from_prop(Q.zero(x) & Q.zero(y)) >>> extract_predargs(props, assump) {x, y, Abs(x*y)} NcXh|]&}t|ztk$|'S) find_symbolsset).0lreq_keyss r z#extract_predargs..s2 E E E1a8!;suu!D!DQ!D!D!Dr") r0all_predicatesr1rtruefalse isinstancer argumentsadd) rrrkeyslkeystmp_keystmpr3symsexprskeyr4s @r extract_predargsrCmsk8K((H  % % ' 'D EEE. ++---* ''))) QVQW% %EH cee  ee  A??DxCEE))t >H cee   E E E E E E EED EEE c+ , ,  S'' 'EE IIcNNNN Lr"ct|tr9t}|D]}|t |z}|S|t S)z Find every :obj:`~.Symbol` in *pred*. Parameters ========== pred : sympy.assumptions.cnf.CNF, or any Expr. )r9rr1r6r0atomsr)predsymbolsas r r0r0sc$%%$$&& ' 'A |A &GG ::f  r"cR|st}t}|D]}t|D]n}tj|}||}|D].}t |tr|t|jz}/o||z |fS)a2 Extract relevant facts from the items in *exprs*. Facts are defined in ``assumptions.sathandlers`` module. This function is recursively called by ``get_all_relevant_facts()``. Parameters ========== exprs : set Expressions whose relevant facts are searched. relevant_facts : sympy.assumptions.cnf.CNF, optional. Pre-discovered relevant facts. Returns ======= exprs : set Candidates for next relevant fact searching. relevant_facts : sympy.assumptions.cnf.CNF Updated relevant facts. Examples ======== Here, we will see how facts relevant to ``Abs(x*y)`` are recursively extracted. On the first run, set containing the expression is passed without pre-discovered relevant facts. The result is a set containing candidates for next run, and ``CNF()`` instance containing facts which are relevant to ``Abs`` and its argument. >>> from sympy import Abs >>> from sympy.assumptions.satask import get_relevant_clsfacts >>> from sympy.abc import x, y >>> exprs = {Abs(x*y)} >>> exprs, facts = get_relevant_clsfacts(exprs) >>> exprs {x*y} >>> facts.clauses #doctest: +SKIP {frozenset({Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}), frozenset({Literal(Q.zero(Abs(x*y)), False), Literal(Q.zero(x*y), True)}), frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True)}), frozenset({Literal(Q.zero(Abs(x*y)), True), Literal(Q.zero(x*y), False)}), frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}), frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True), Literal(Q.odd(Abs(x*y)), False)}), frozenset({Literal(Q.positive(Abs(x*y)), False), Literal(Q.zero(Abs(x*y)), False)})} We pass the first run's results to the second run, and get the expressions for next run and updated facts. >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts) >>> exprs {x, y} On final run, no more candidate is returned thus we know that all relevant facts are successfully retrieved. >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts) >>> exprs set() ) rr1r to_CNF_andr6r9r r:)rArelevant_factsnewexprsexprfactnewfactrBs r get_relevant_clsfactsrQsL uuH33'-- 3 3Dj&&G+0099N--// 3 3c#3443CM 2 22H 3 3 e ^ ++r"c d}t}t} |dkrt|||}||z}t||\}}|dz }||krn|sn?|r`t} t d|Dr!| t t d|Dr!| tt} | | dfd} g} g} t| j }t|D]2\}| fd| j Dz } | | | j ||zz } 3ttt!| t#dt| dz}t| |}nt}|||S) al Extract all relevant facts from *proposition* and *assumptions*. This function extracts the facts by recursively calling ``get_relevant_clsfacts()``. Extracted facts are converted to ``EncodedCNF`` and returned. Parameters ========== proposition : sympy.assumptions.cnf.CNF CNF generated from proposition expression. assumptions : sympy.assumptions.cnf.CNF CNF generated from assumption expression. context : sympy.assumptions.cnf.CNF CNF generated from assumptions context. use_known_facts : bool, optional. If ``True``, facts from ``sympy.assumptions.ask_generated`` module are encoded as well. iterations : int, optional. Number of times that relevant facts are recursively extracted. Default is infinite times until no new fact is found. Returns ======= sympy.assumptions.cnf.EncodedCNF Examples ======== >>> from sympy import Q >>> from sympy.assumptions.cnf import CNF >>> from sympy.assumptions.satask import get_all_relevant_facts >>> from sympy.abc import x, y >>> props = CNF.from_prop(Q.nonzero(x*y)) >>> assump = CNF.from_prop(Q.nonzero(x)) >>> context = CNF.from_prop(Q.nonzero(y)) >>> get_all_relevant_facts(props, assump, context) #doctest: +SKIP rTc3PK|]!}|jttkV"dSN)kindrrr2rNs r z)get_all_relevant_facts..Rs1IIttyJz222IIIIIIr"c3VK|]$}|jtkp|jtkV%dSrU)rVrrrWs r rXz)get_all_relevant_facts..Us5aatj(Idi=.Haaaaaar"c"|dkr||zS||z S)Nrr/)litdeltas r translate_literalz1get_all_relevant_facts..translate_literal[sQwwU{"U{"r"c$fd|DS)Nc.g|]}fd|DS)c(h|]}|Sr/r/)r2ir\r]s r r5zLget_all_relevant_facts..translate_data...bs'AAAQ&&q%00AAAr"r/)r2clauser\r]s r zBget_all_relevant_facts..translate_data..bs1UUUfAAAAA&AAAUUUr"r/)datar\r]s `r translate_dataz.get_all_relevant_facts..translate_dataas"UUUUUPTUUU Ur"c&g|] }|Sr/r/)r2rFrNs r rcz*get_all_relevant_facts..gs!BBBtT BBBr")rr1rCrQany add_clausesrrrfrom_cnflenrG enumeraterddictlistzipranger)rrrrrrarL all_exprsrAknown_facts_CNF kf_encodedrerdrGn_litencodingctxrNr]s @@r rr s/h AUUNI  66$[+wGGEU 5e^ L L~ Q ??    %% IIyIII I I F  ' '(B(D(D E E E aaW`aaa a a F  ' '(B(D(D E E E\\ O,,, # # #  V V V V VJ&'' ++ ? ?GAt BBBBz/ABBB BG NN:?AI>> >DDS%3w<<>*B*BCCDDEEx((ll^$$$ Jr")NNrU)__doc__sympy.core.singletonrsympy.core.symbolrsympy.core.kindrrsympy.assumptions.ask_generatedrrsympy.assumptions.assumer r sympy.assumptions.sathandlersr sympy.corer sympy.logic.inferencer sympy.assumptions.cnfrrsympy.matrices.kindrr!rrCr0rQrr/r"r rsz#"""""$$$$$$55555555bbbbbbbbIIIIIIII======------11111111******%)2DA4A4A4A4H55507777r$R,R,R,R,lddddddr"