ó ¡¼™\c@ sçdZddlmZmZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZddlmZmZd„Zd„Zd „Zid „Zd „Zd „Zd „Zd„Zd„Zd„ZdS(s&Implementation of DPLL algorithm Further improvements: eliminate calls to pl_true, implement branching rules, efficient unit propagation. References: - https://en.wikipedia.org/wiki/DPLL_algorithm - https://www.researchgate.net/publication/242384772_Implementations_of_the_DPLL_Algorithm iÿÿÿÿ(tprint_functiontdivision(trange(tdefault_sort_key(tOrtNott conjunctst disjunctstto_cnft to_int_reprt_find_predicates(tpl_truetliteral_symbolcC s¿tt|ƒƒ}t|kr"tStt|ƒdtƒ}ttdt|ƒdƒƒ}t ||ƒ}t ||iƒ}|s„|Si}x.|D]&}|j i||||d6ƒq‘W|S(s> Check satisfiability of a propositional sentence. It returns a model rather than True when it succeeds >>> from sympy.abc import A, B >>> from sympy.logic.algorithms.dpll import dpll_satisfiable >>> dpll_satisfiable(A & ~B) {A: True, B: False} >>> dpll_satisfiable(A & ~A) False tkeyi( RRtFalsetsortedR RtsetRtlenR t dpll_int_reprtupdate(texprtclausestsymbolstsymbols_int_reprtclauses_int_reprtresulttoutputR ((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pytdpll_satisfiables   $c C sÕt||ƒ\}}x_|rv|ji||6ƒ|j|ƒ|sO|}nt||ƒ}t||ƒ\}}qWt||ƒ\}}x_|rí|ji||6ƒ|j|ƒ|sÆ|}nt||ƒ}t||ƒ\}}qWg}xI|D]A}t||ƒ}|tkr tS|tk rû|j|ƒqûqûW|sJ|S|sT|S|j ƒ}|j ƒ}|jit|6ƒ|jit|6ƒ|} t t||ƒ||ƒpÔt t|t |ƒƒ| |ƒS(sí Compute satisfiability in a partial model. Clauses is an array of conjuncts. >>> from sympy.abc import A, B, D >>> from sympy.logic.algorithms.dpll import dpll >>> dpll([A, B, D], [A, B], {D: False}) False ( tfind_unit_clauseRtremovetunit_propagatetfind_pure_symbolR RtTruetappendtpoptcopytdpllR( RRtmodeltPtvaluetunknown_clausestctvalt model_copyt symbols_copy((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR$/sD            c C sËt||ƒ\}}x_|rv|ji||6ƒ|j|ƒ|sO| }nt||ƒ}t||ƒ\}}qWt||ƒ\}}x_|rí|ji||6ƒ|j|ƒ|sÆ| }nt||ƒ}t||ƒ\}}qWg}xI|D]A}t||ƒ}|tkr tS|tk rû|j|ƒqûqûW|sJ|S|j ƒ}|j ƒ}|jit|6ƒ|jit|6ƒ|j ƒ} t t||ƒ||ƒpÊt t|| ƒ| |ƒS(sô Compute satisfiability in a partial model. Arguments are expected to be in integer representation >>> from sympy.logic.algorithms.dpll import dpll_int_repr >>> dpll_int_repr([{1}, {2}, {3}], {1, 2}, {3: False}) False ( tfind_unit_clause_int_reprRRtunit_propagate_int_reprtfind_pure_symbol_int_reprtpl_true_int_reprRR R!R"R#R( RRR%R&R'R(R)R*R+R,((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR`s@             cC s„t}xw|D]o}|dkrH|j| ƒ}|dk rW| }qWn|j|ƒ}|tkrgtS|dkr d}q q W|S(sf Lightweight version of pl_true. Argument clause represents the set of args of an Or clause. This is used inside dpll_int_repr, it is not meant to be used directly. >>> from sympy.logic.algorithms.dpll import pl_true_int_repr >>> pl_true_int_repr({1, 2}, {1: False}) >>> pl_true_int_repr({1, 2}, {1: False, 2: False}) False iN(RtgettNoneR (tclauseR%Rtlittp((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR0s        cC sµg}x¨|D] }|jtkr5|j|ƒq nxu|jD]]}||krŒ|jtg|jD]}||kre|^qeŒƒPn||kr?Pq?q?W|j|ƒq W|S(s Returns an equivalent set of clauses If a set of clauses contains the unit clause l, the other clauses are simplified by the application of the two following rules: 1. every clause containing l is removed 2. in every clause that contains ~l this literal is deleted Arguments are expected to be in CNF. >>> from sympy import symbols >>> from sympy.abc import A, B, D >>> from sympy.logic.algorithms.dpll import unit_propagate >>> unit_propagate([A | B, D | ~B, B], B) [D, B] (tfuncRR!targs(RtsymbolRR)targtx((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR«s   6 cC s1| h}g|D]}||kr||^qS(sï Same as unit_propagate, but arguments are expected to be in integer representation >>> from sympy.logic.algorithms.dpll import unit_propagate_int_repr >>> unit_propagate_int_repr([{1, 2}, {3, -2}, {2}], 2) [{3}] ((RtstnegatedR3((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR.Ís cC s“xŒ|D]„}tt}}xX|D]P}| rI|t|ƒkrIt}n| r!t|ƒt|ƒkr!t}q!q!W||kr||fSqWdS(sE Find a symbol and its value if it appears only as a positive literal (or only as a negative) in clauses. >>> from sympy import symbols >>> from sympy.abc import A, B, D >>> from sympy.logic.algorithms.dpll import find_pure_symbol >>> find_pure_symbol([A, B, D], [A|~B,~B|~D,D|A]) (A, True) N(NN(RRR RR2(RR(tsymt found_post found_negR)((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyRÛs      cC s™tƒj|Œ}|j|ƒ}|jg|D] }| ^q.ƒ}x%|D]}| |krK|tfSqKWx&|D]}| |krs| tfSqsWdS(s Same as find_pure_symbol, but arguments are expected to be in integer representation >>> from sympy.logic.algorithms.dpll import find_pure_symbol_int_repr >>> find_pure_symbol_int_repr({1,2,3}, ... [{1, -2}, {-2, -3}, {3, 1}]) (1, True) N(NN(Rtuniont intersectionR RR2(RR(t all_symbolsR>R;R?R5((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR/ós #    cC s„x}|D]u}d}xPt|ƒD]B}t|ƒ}||kr |d7}|t|tƒ }}q q W|dkr||fSqWdS(s% A unit clause has only 1 variable that is not bound in the model. >>> from sympy import symbols >>> from sympy.abc import A, B, D >>> from sympy.logic.algorithms.dpll import find_unit_clause >>> find_unit_clause([A | B | D, B | ~D, A | ~B], {A:True}) (B, False) iiN(NN(RR t isinstanceRR2(RR%R3tnum_not_in_modeltliteralR=R&R'((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR s     cC st|ƒtd„|DƒƒB}xZ|D]R}||}t|ƒdkr'|jƒ}|dkrl| tfS|tfSq'q'WdS(s Same as find_unit_clause, but arguments are expected to be in integer representation. >>> from sympy.logic.algorithms.dpll import find_unit_clause_int_repr >>> find_unit_clause_int_repr([{1, 2, 3}, ... {2, -3}, {1, -2}], {1: True}) (2, False) cs s|] }| VqdS(N((t.0R=((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pys ,siiN(NN(RRR"RR R2(RR%tboundR3tunboundR5((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyR-!s      N(t__doc__t __future__RRtsympy.core.compatibilityRtsympyRtsympy.logic.boolalgRRRRRR R tsympy.logic.inferenceR R RR$RR0RR.RR/RR-(((s:lib/python2.7/site-packages/sympy/logic/algorithms/dpll.pyt s4  1 0  "