\c@ sdZddlmZmZddlmZddlmZmZddl m Z ddl m Z ddl mZddlmZmZmZmZdd lmZmZmZdd lmZdd lmZdd lmZmZdd lm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'dZ(de fdYZ)de)fdYZ*deee*fdYZ+deee*fdYZ,e+Z-e,Z.e-e_-e.e_.de e/d4Z?e@d5ZAeBd6ZCeBd7ZDe@d8ZEd9ZFd:ZGd;ZHd<ZId=ZJd>ZKd?ZLdRd@ZNe@dAZOdBZPdCZQdDZRdEZSdFZTdGZUdHZVdRdIZWdRdJZXdKZYdRe@eBdLZZdMZ[dNZ\dOZ]dPZ^dQZ_dRS(Ss" Boolean algebra module for SymPy i(tprint_functiontdivision(t defaultdict(t combinationstproduct(tAdd(tBasic(tcacheit(torderedtrangetwith_metaclasstas_int(t Applicationt Derivativet count_ops(tNumber(t LatticeOp(t SingletontS(t convertert_sympifytsympify(tsifttibin(t filldedentcC sddlm}|tkr#tjS|tkr6tjSt||rr|j}|dkr^|S|rktjStjSt|t r|St d|dS(sLike bool, return the Boolean value of an expression, e, which can be any instance of Boolean or bool. Examples ======== >>> from sympy import true, false, nan >>> from sympy.logic.boolalg import as_Boolean >>> from sympy.abc import x >>> as_Boolean(1) is true True >>> as_Boolean(x) x >>> as_Boolean(2) Traceback (most recent call last): ... TypeError: expecting bool or Boolean, not `2`. i(tSymbols$expecting bool or Boolean, not `%s`.N( tsympy.core.symbolRtTrueRttruetFalsetfalset isinstancetis_zerotNonetBooleant TypeError(teRtz((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt as_Booleans    R"cB seZdZgZdZeZdZeZdZdZ dZ e Z e Z dZ e ZdZedZd Zed ZRS( sDA boolean object is an object for which logic operations make sense.cC s t||S(sOverloading for & operator(tAnd(tselftother((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt__and__=scC s t||S(sOverloading for |(tOr(R(R)((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt__or__CscC s t|S(sOverloading for ~(tNot(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt __invert__IscC s t||S(sOverloading for >>(tImplies(R(R)((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt __rshift__MscC s t||S(sOverloading for <<(R/(R(R)((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt __lshift__QscC s t||S(N(tXor(R(R)((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt__xor__XscC sddlm}ddlm}|j|s>|j|rMtdn|j|jko~|tt|| S(s Returns True if the given formulas have the same truth table. For two formulas to be equal they must have the same literals. Examples ======== >>> from sympy.abc import A, B, C >>> from sympy.logic.boolalg import And, Or, Not >>> (A >> B).equals(~B >> ~A) True >>> Not(And(A, B, C)).equals(And(Not(A), Not(B), Not(C))) False >>> Not(And(A, Not(A))).equals(Or(B, Not(B))) False i(t satisfiable(t Relationalshandling of relationals( tsympy.logic.inferenceR4tsympy.core.relationalR5thastNotImplementedErrortatomsR-t Equivalent(R(R)R4R5((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytequals]s cC s|S(N((R(tsimplify((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytto_nnfvscC sddlm}ddlm}|j}t|dkr|j}i}x|j|D]s}|||d kr]|j }|t j t j t j fkr|j|||>> from sympy import Symbol, Eq, Or, And >>> x = Symbol('x', real=True) >>> Eq(x, 0).as_set() {0} >>> (x > 0).as_set() Interval.open(0, oo) >>> And(-2 < x, x < 2).as_set() Interval.open(-2, 2) >>> Or(x < -2, 2 < x).as_set() Union(Interval.open(-oo, -2), Interval.open(2, oo)) i(t periodicity(R5iis as_set is not implemented for relationals with periodic solutions sGSorry, as_set has not yet been implemented for multivariate expressionsN(iN(tsympy.calculus.utilR?R7R5t free_symbolstlentpopR:R!t _eval_as_setRtEmptySett UniversalSettRealst as_relationalR9Rtsubs(R(R?R5tfreetxtrepstrts((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytas_setzs    cC sfddlm}m}tjg|jD]6}|jsV|jsVt|||fr)|j ^q)S(Ni(tEqtNe( R7RPRQtsettuniontargst is_Booleant is_SymbolRtbinary_symbols(R(RPRQti((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRWs(t__name__t __module__t__doc__t __slots__R*t__rand__R,t__ror__R.R0R1t __rrshift__t __rlshift__R3t__rxor__R<RR>ROtpropertyRW(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR"8s"         (t BooleanAtomcB seZdZeZeZdZdZdZe dZ ddZ e Z e Ze Ze Ze Ze Ze Ze Ze Ze Ze Ze Ze Ze Ze ZdZeZeZeZRS(s5 Base class of BooleanTrue and BooleanFalse. i cO s|S(N((R(tatkw((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR=scO s|S(N((R(RdRe((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytexpandscC s|S(N((R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt canonicalscC stddS(Ns(BooleanAtom not allowed in this context.(R#(R(R)((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_noopscC s&ddlm}t|ddS(Ni(Rs A Boolean argument can only be used in Eq and Ne; all other relationals expect real expressions. (tsympy.utilities.miscRR#(R(R)R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt__lt__sN( RYRZR[RRUtis_Atomt _op_priorityR=RfRbRgR!Rht__add__t__radd__t__sub__t__rsub__t__mul__t__rmul__t__pow__t__rpow__t__rdiv__t __truediv__t__div__t __rtruediv__t__mod__t__rmod__t _eval_powerRjt__le__t__gt__t__ge__(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRcs6    t BooleanTruecB s>eZdZdZeZdZedZdZRS(sd SymPy version of True, a singleton that can be accessed via S.true. This is the SymPy version of True, for use in the logic module. The primary advantage of using true instead of True is that shorthand boolean operations like ~ and >> will work as expected on this class, whereas with True they act bitwise on 1. Functions in the logic module will return this class when they evaluate to true. Notes ===== There is liable to be some confusion as to when ``True`` should be used and when ``S.true`` should be used in various contexts throughout SymPy. An important thing to remember is that ``sympify(True)`` returns ``S.true``. This means that for the most part, you can just use ``True`` and it will automatically be converted to ``S.true`` when necessary, similar to how you can generally use 1 instead of ``S.One``. The rule of thumb is: "If the boolean in question can be replaced by an arbitrary symbolic ``Boolean``, like ``Or(x, y)`` or ``x > 1``, use ``S.true``. Otherwise, use ``True``" In other words, use ``S.true`` only on those contexts where the boolean is being used as a symbolic representation of truth. For example, if the object ends up in the ``.args`` of any expression, then it must necessarily be ``S.true`` instead of ``True``, as elements of ``.args`` must be ``Basic``. On the other hand, ``==`` is not a symbolic operation in SymPy, since it always returns ``True`` or ``False``, and does so in terms of structural equality rather than mathematical, so it should return ``True``. The assumptions system should use ``True`` and ``False``. Aside from not satisfying the above rule of thumb, the assumptions system uses a three-valued logic (``True``, ``False``, ``None``), whereas ``S.true`` and ``S.false`` represent a two-valued logic. When in doubt, use ``True``. "``S.true == True is True``." While "``S.true is True``" is ``False``, "``S.true == True``" is ``True``, so if there is any doubt over whether a function or expression will return ``S.true`` or ``True``, just use ``==`` instead of ``is`` to do the comparison, and it will work in either case. Finally, for boolean flags, it's better to just use ``if x`` instead of ``if x is True``. To quote PEP 8: Don't compare boolean values to ``True`` or ``False`` using ``==``. * Yes: ``if greeting:`` * No: ``if greeting == True:`` * Worse: ``if greeting is True:`` Examples ======== >>> from sympy import sympify, true, false, Or >>> sympify(True) True >>> _ is True, _ is true (False, True) >>> Or(true, false) True >>> _ is true True Python operators give a boolean result for true but a bitwise result for True >>> ~true, ~True (False, -2) >>> true >> true, True >> True (True, 0) Python operators give a boolean result for true but a bitwise result for True >>> ~true, ~True (False, -2) >>> true >> true, True >> True (True, 0) See Also ======== sympy.logic.boolalg.BooleanFalse cC stS(N(R(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt __nonzero__9scC s ttS(N(thashR(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt__hash__>scC stjS(N(RR(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytnegatedAscC stjS(s Rewrite logic operators and relationals in terms of real sets. Examples ======== >>> from sympy import true >>> true.as_set() UniversalSet() (RRF(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyROEs ( RYRZR[Rt__bool__RRbRRO(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs Z  t BooleanFalsecB s>eZdZdZeZdZedZdZRS(s SymPy version of False, a singleton that can be accessed via S.false. This is the SymPy version of False, for use in the logic module. The primary advantage of using false instead of False is that shorthand boolean operations like ~ and >> will work as expected on this class, whereas with False they act bitwise on 0. Functions in the logic module will return this class when they evaluate to false. Notes ====== See note in :py:class`sympy.logic.boolalg.BooleanTrue` Examples ======== >>> from sympy import sympify, true, false, Or >>> sympify(False) False >>> _ is False, _ is false (False, True) >>> Or(true, false) True >>> _ is true True Python operators give a boolean result for false but a bitwise result for False >>> ~false, ~False (True, -1) >>> false >> false, False >> False (True, 0) See Also ======== sympy.logic.boolalg.BooleanTrue cC stS(N(R(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR|scC s ttS(N(RR(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRscC stjS(N(RR(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRscC stjS(s Rewrite logic operators and relationals in terms of real sets. Examples ======== >>> from sympy import false >>> false.as_set() EmptySet() (RRE(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyROs ( RYRZR[RRRRbRRO(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRSs (  cC s|r tjStjS(N(RRR(RK((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytttBooleanFunctioncB seZdZeZdZdeeedZdZ e Z e Z e Z e dZedZe dZdZd Zd d ZRS( suBoolean function is a function that lives in a boolean space It is used as base class for And, Or, Not, etc. c C sM|jg|jD]*}|jd|d|d|d|^q}t|S(Ntratiotmeasuretrationaltinverse(tfuncRTt_eval_simplifytsimplify_logic(R(RRRRRdtrv((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs :g333333?cC s|j||||S(N(R(R(RRRR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR=scC s&ddlm}t|ddS(Ni(Rs A Boolean argument can only be used in Eq and Ne; all other relationals expect real expressions. (RiRR#(R(R)R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRjsc G s_ddlm}m}m}g|D]}t|^q#}tjg|D]}|j^qK}tjg|D]}|j|^qs}i}x|D]} x|D]} | |kr| | j krt | ||frt j | j kpt j| j ks4t j|| scO s|jdt}tg}x|D]}t|sI|j|}n|rt||rj|j}n |f}xD|D],}t||kr|jS|j |qzWq%|j |q%W||S(NR=( tgetRRRt is_literalR>RRTR-tzerotadd(tclsRTtkwargsR=targsettargRd((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs      cO s |jdtt|||S(Ntevaluate(t setdefaultRR (R(tsymbolst assumptions((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytdiffscC sddlm}ddlm}||jkri|d||j|d|j|dfdtfS||jkr{ntj SdS(Ni(RP(t Piecewiseii( R7RPt$sympy.functions.elementary.piecewiseRRWRIRRARtZero(R(RKRPR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_eval_derivatives* c sddlmm}|d kr7|d k r7|}nt}t|jfddt\}} t|dkrz|St|jddt\}} g|D]} | j^q}x|rft|dkrft }t t |}g} xt t |dD]\\} } \}}xt |D]\}\}}g}|j| |}|j|}|r|j||fn|j| j|}|j|}|r|j||fn|j| |j}|j|}|r|j||fn|j| j|j}|j|}|rC|j||fn|r+x|D]~\}}|j|}||kr{|St|tsP||||}|dkr| j|| ||ffqqPqPWq+q+WqW| rt tt| d d } | d\}}|\} }}||=|| =|d ksJ||krZ|j|nt}qqW|jgt |D]} || ^qz| | }|S( s Replace patterns of Relational Parameters ========== rv : Expr Boolean expression patterns : tuple Tuple of tuples, with (pattern to simplify, simplified pattern) measure : function Simplification measure dominatingvalue : boolean or None The dominating value for the function of consideration. For example, for And S.false is dominating. As soon as one expression is S.false in And, the whole expression is S.false. replacementvalue : boolean or None, optional The resulting value for the whole expression if one argument evaluates to dominatingvalue. For example, for Nand S.false is dominating, but in this case the resulting value is S.true. Default is None. If replacementvalue is None and dominatingvalue is not None, replacementvalue = dominatingvalue i(R5t _canonicalc s t|S(N(R(RX(R5(s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR#RtbinaryicS std|jDS(Ncs s|]}|jtk VqdS(N(tis_realR(t.0RN((s2lib/python2.7/site-packages/sympy/logic/boolalg.pys 's(tallRA(RX((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR's iitkeycS s|dS(Ni((tpair((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR^RN(R7R5RR!RRRTRBRgRtlistRRt enumerateRtmatchtappendtreversedRIRtITEtsorted(R(RtpatternsRtdominatingvaluetreplacementvalueRtchangedtReltnonRelt nonRealRelRXtresultstpitjtpjtktpatterntsimptrestoldexprttmprestnpt costsavingtcostt replacementtnewrel((R5s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt"_apply_patternbased_simplificationsp .  1 0N(RYRZR[RRURRRR=RjR|R~R}t classmethodRR>RRRR!R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs       R'cB sAeZdZeZeZdZe dZ dZ dZ RS(s Logical AND function. It evaluates its arguments in order, giving False immediately if any of them are False, and True if they are all True. Examples ======== >>> from sympy.core import symbols >>> from sympy.abc import x, y >>> from sympy.logic.boolalg import And >>> x & y x & y Notes ===== The ``&`` operator is provided as a convenience, but note that its use here is different from its normal use in Python, which is bitwise and. Hence, ``And(a, b)`` and ``a & b`` will return different things if ``a`` and ``b`` are integers. >>> And(x, y).subs(x, 1) y c sg}g}tj|}xt|D]y}|jr|j}||krRq(n|jjtfd|DrtjgS|j |n|j |q(Wt j |t S(Nc3 s|]}|kVqdS(N((RRM(tnc(s2lib/python2.7/site-packages/sympy/logic/boolalg.pys s( RRRt is_RelationalRgRtanyRRRRt_new_args_filterR'(RRTtnewargsRRKtc((Rs2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs     c sXddlmmddlm}tt|j||||}t|tsZ|St |j fddt \}}|s|St |fddt \} } | s|Si} i} | rt t g| D]} | j | f^qd} g} xd| krx| jdD] \}}|j}|j|ks]||jj kryt||jtd t|\}}|j|| |}|||||kr|}n| j|w$Wqtk rqXn|| kr| j|j|j| |q$|j| |<| j|q$Wtt}x^| D]V}xM| |D]A\}}|j| }|j }|t|j||fqYWqHW|} qWnx8| D]0}| jg| |D]\}}|^qqWg| D]}|j| ^q} |jg| | D]} | j^q|}t}|j|||tS( Ni(tEqualityR5(t linear_coeffsc s t|S(N(R(RX(R5(s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRRRc s t|S(N(R(RX(R(s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRRcS st|dS(Ni(RB(RK((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRRiR(R7RR5tsympy.solvers.solvesetRtsuperR'RRRRTRRRARCtlhstrhstrewriteRRRRt ValueErrorRRRIRBtextendRgtsimplify_patterns_andR(R(RRRRRRRRteqsR)RLtsiftedRXRJR$RKtmtbtenewtresiftedRtfteiR((RR5s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRsh$"  !!    #    %  ."-  cC s6ddlm}|g|jD]}|j^qS(Ni(t Intersection(tsympy.sets.setsRRTRO(R(RR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRDsN( RYRZR[RRRtidentityR!tnargsRRRRD(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR'qs >> from sympy.core import symbols >>> from sympy.abc import x, y >>> from sympy.logic.boolalg import Or >>> x | y x | y Notes ===== The ``|`` operator is provided as a convenience, but note that its use here is different from its normal use in Python, which is bitwise or. Hence, ``Or(a, b)`` and ``a | b`` will return different things if ``a`` and ``b`` are integers. >>> Or(x, y).subs(x, 0) y c sg}g}tj|}x|D]y}|jr|j}||krLq"n|jjtfd|Dr~tjgS|j|n|j|q"Wt j |t S(Nc3 s|]}|kVqdS(N((RRM(R(s2lib/python2.7/site-packages/sympy/logic/boolalg.pys s( RRRRgRRRRRRRR+(RRTRRRKR((Rs2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs      cC s6ddlm}|g|jD]}|j^qS(Ni(tUnion(RRRTRO(R(RR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRDscC sVtt|j||||}t|ts4|St}|j|||tjS(N(RR+RRtsimplify_patterns_orRRR(R(RRRRRR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs  ( RYRZR[RRRRRRRDR(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR+s  R-cB s8eZdZeZedZdZedZRS(sI Logical Not function (negation) Returns True if the statement is False Returns False if the statement is True Examples ======== >>> from sympy.logic.boolalg import Not, And, Or >>> from sympy.abc import x, A, B >>> Not(True) False >>> Not(False) True >>> Not(And(True, False)) True >>> Not(Or(True, False)) False >>> Not(And(And(True, x), Or(x, False))) ~x >>> ~x ~x >>> Not(And(Or(A, B), Or(~A, ~B))) ~((A | B) & (~A | ~B)) Notes ===== - The ``~`` operator is provided as a convenience, but note that its use here is different from its normal use in Python, which is bitwise not. In particular, ``~a`` and ``Not(a)`` will be different if ``a`` is an integer. Furthermore, since bools in Python subclass from ``int``, ``~True`` is the same as ``~1`` which is ``-2``, which has a boolean value of True. To avoid this issue, use the SymPy boolean types ``true`` and ``false``. >>> from sympy import true >>> ~True -2 >>> ~true False cC sddlm}m}m}m}m}m}t|tsO|t t fkr]|rYt St S|j rq|jdSt||r||jSt||r||jSt||r||jSt||r||jSt||r||jSt||r||jSdS(Ni(Rt GreaterThantLessThantStrictGreaterThantStrictLessThant Unequalityi(tsympyRRRRRRRRRRRRtis_NotRT(RRRRRRRR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytevalTs".!       cC s|jdjjtjS(s Rewrite logic operators and relationals in terms of real sets. Examples ======== >>> from sympy import Not, Symbol >>> x = Symbol('x') >>> Not(x > 0).as_set() Interval(-oo, 0) i(RTROt complementRRG(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRDks cC st|r|S|jd}|j|j}}|tkrctjd|g|D] }|^qOS|tkrtjd|g|D] }|^qS|tkr|\}}tj||d|S|tkrtjt|tg|D] }|^qd|S|tkrg}x}t dt |ddD]_} xVt || D]E} g|D]} | | krr| n| ^qY} |j t| qLWq6Wtjd||S|t kr|\}}} tjt|| t||d|Std|dS(NiR=iis!Illegal operator %s in expression(RRTRR'R+RR/R;R2R RBRRRR(R(R=texprRRTRRdRtresultRXtnegRNtclauseR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR>ys2   ' '   / #, +( RYRZR[RRRRRDR>(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR-#s - R2cB sAeZdZdZeedZedZdZ RS(sg Logical XOR (exclusive OR) function. Returns True if an odd number of the arguments are True and the rest are False. Returns False if an even number of the arguments are True and the rest are False. Examples ======== >>> from sympy.logic.boolalg import Xor >>> from sympy import symbols >>> x, y = symbols('x y') >>> Xor(True, False) True >>> Xor(True, True) False >>> Xor(True, False, True, True, False) True >>> Xor(True, False, True, False) False >>> x ^ y Xor(x, y) Notes ===== The ``^`` operator is provided as a convenience, but note that its use here is different from its normal use in Python, which is bitwise xor. In particular, ``a ^ b`` and ``Xor(a, b)`` will be different if ``a`` and ``b`` are integers. >>> Xor(x, y).subs(y, 0) x cO stg}tt|j|||}x|jD]}t|ts[|ttfkrp|r4t }qpq4nt|trxe|j D].}||kr|j |n |j |qWq4||kr|j |q4|j |q4Wg|D]'}|j r||j|jjf^q}t} g} xt|D]\} \}} } x_t| dt|D]A}||d \}}|| kr| } Pqg|| krgPqgqgWq8| j||fq8W| rt |kr|j t n |j t nx.| D]&\}}|j ||j |qWt|dkr>tSt|dkrZ|jSt|kr|j ttt|Stt||_t||_|SdS(Niii(RRRR2t__new__t_argsRRRRRRTtremoveRRRgRRR RBRRRCR-ttupleRt frozensett_argset(RRTRRtobjRRdRMRtoddRRXRRRtrjtcjR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRsT ! / 1"   +    cC stt|jS(N(RRR(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRTscC sg}xtdt|jddD]e}x\t|j|D]H}g|jD]}||krh|n|^qO}|jt|q?Wq&Wtjd||S(NiiiR=(R RBRTRRR+R'R(R(R=RTRXRRNR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR>s &/c C su|jg|jD]*}|jd|d|d|d|^q}t|tsV|St}|j|||dS(NRRRR(RRTRRR2tsimplify_patterns_xorRR!(R(RRRRRdRR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs :  ( RYRZR[RRbRRTRR>R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR2s ' 0 tNandcB seZdZedZRS(s Logical NAND function. It evaluates its arguments in order, giving True immediately if any of them are False, and False if they are all True. Returns True if any of the arguments are False Returns False if all arguments are True Examples ======== >>> from sympy.logic.boolalg import Nand >>> from sympy import symbols >>> x, y = symbols('x y') >>> Nand(False, True) True >>> Nand(True, True) False >>> Nand(x, y) ~(x & y) cG stt|S(N(R-R'(RRT((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR)s(RYRZR[RR(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRstNorcB seZdZedZRS(s* Logical NOR function. It evaluates its arguments in order, giving False immediately if any of them are True, and True if they are all False. Returns False if any argument is True Returns True if all arguments are False Examples ======== >>> from sympy.logic.boolalg import Nor >>> from sympy import symbols >>> x, y = symbols('x y') >>> Nor(True, False) False >>> Nor(True, True) False >>> Nor(False, True) False >>> Nor(False, False) True >>> Nor(x, y) ~(x | y) cG stt|S(N(R-R+(RRT((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRKs(RYRZR[RR(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR.stXnorcB seZdZedZRS(s  Logical XNOR function. Returns False if an odd number of the arguments are True and the rest are False. Returns True if an even number of the arguments are True and the rest are False. Examples ======== >>> from sympy.logic.boolalg import Xnor >>> from sympy import symbols >>> x, y = symbols('x y') >>> Xnor(True, False) False >>> Xnor(True, True) True >>> Xnor(True, False, True, True, False) False >>> Xnor(True, False, True, False) True cG stt|S(N(R-R2(RRT((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRjs(RYRZR[RR(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRPsR/cB s)eZdZedZedZRS(s Logical implication. A implies B is equivalent to !A v B Accepts two Boolean arguments; A and B. Returns False if A is True and B is False Returns True otherwise. Examples ======== >>> from sympy.logic.boolalg import Implies >>> from sympy import symbols >>> x, y = symbols('x y') >>> Implies(True, False) False >>> Implies(False, False) True >>> Implies(True, True) True >>> Implies(False, True) True >>> x >> y Implies(x, y) >>> y << x Implies(x, y) Notes ===== The ``>>`` and ``<<`` operators are provided as a convenience, but note that their use here is different from their normal use in Python, which is bit shifts. Hence, ``Implies(a, b)`` and ``a >> b`` will return different things if ``a`` and ``b`` are integers. In particular, since Python considers ``True`` and ``False`` to be integers, ``True >> True`` will be the same as ``1 >> 1``, i.e., 0, which has a truth value of False. To avoid this issue, use the SymPy objects ``true`` and ``false``. >>> from sympy import true, false >>> True >> False 1 >>> true >> false False cG sRykg}xR|D]J}t|ts1|dkrM|j|rCtntq|j|qW|\}}Wn3tk rtdt|t|fnX|tks|tks|tks|tkrtt ||S||krt j S|j r>|j r>|j |j kr"t j S|jj |j krN|Sntj||SdS(Niis:%d operand(s) used for an Implies (pairs are required): %s(ii(RRRRRRRBtstrR+R-RRRRgRRR(RRTRRKtAtB((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs*   0 cC s&|j\}}tj||d|S(NR=(RTR+R(R(R=RdR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR>s(RYRZR[RRRR>(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR/os/R;cB s8eZdZdZeedZedZRS(s Equivalence relation. Equivalent(A, B) is True iff A and B are both True or both False Returns True if all of the arguments are logically equivalent. Returns False otherwise. Examples ======== >>> from sympy.logic.boolalg import Equivalent, And >>> from sympy.abc import x, y >>> Equivalent(False, False, False) True >>> Equivalent(True, False, False) False >>> Equivalent(x, And(x, True)) True cO sWddlm}g|D]}t|^q}t|}xX|D]P}t|tsi|ttgkrB|j||j |rtntqBqBWg}x?|D]7}t||r|j ||j |j j fqqWg} xt |D]\} \}} } xht| dt|D]M} || d \}}|| krJtS|| kr | j ||fPq q WqWx;| D]3\}}|j||j||j tq|Wt|dkrtSt|kr|jtt|St|kr#|jttg|D] }|^qSt|}tt|j||}||_|S(Ni(R5ii(R7R5RRRRRRRtdiscardRRRgRRR RBRRRR'RRR;RR(RRTtoptionsR5RRRKRRMRRXRRRRRRdRRR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRsH  !   &"             cC stt|jS(N(RRR(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRTscC sg}x>t|j|jdD]#\}}|jt||q W|jt|jd|jdtjd||S(NiiiR=(tzipRTRR+R'R(R(R=RTRdR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR>s &%( RYRZR[RRbRRTRR>(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR;s  'RcB sDeZdZdZedZedZdZdZ RS(s If then else clause. ITE(A, B, C) evaluates and returns the result of B if A is true else it returns the result of C. All args must be Booleans. Examples ======== >>> from sympy.logic.boolalg import ITE, And, Xor, Or >>> from sympy.abc import x, y, z >>> ITE(True, False, True) False >>> ITE(Or(True, False), And(True, True), Xor(True, True)) True >>> ITE(x, y, z) ITE(x, y, z) >>> ITE(True, x, y) x >>> ITE(False, x, y) y >>> ITE(x, y, y) y Trying to use non-Boolean args will generate a TypeError: >>> ITE(True, [], ()) Traceback (most recent call last): ... TypeError: expecting bool, Boolean or ITE, not `[]` c O sddlm}m}t|dkr7tdn|\}}}t|||frktt||f\}}tj g||fD]}|j ^q} tt|j | dkr|} |j t jkr|j}ne|jt jkr|j }nG|j t jkr$|j}n(|jt jkrC|j }n t j}t| |rh|}qhqntj|||\}}}d} |jdtr|j|||} n| dkrtj||||dt} n| S(Ni(RPRQisexpecting exactly 3 argsiR(R7RPRQRBRRtmapR&RRRSRWRTRRRRRRRR!RRRRR( RRTRRPRQRdRRRXRt_aR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR(s8.      !cG sddlm}m}|\}}}t|||fr|}tj|jkry|jtjkrm|jn|j}nAtj |jkr|jtj kr|jn|j}nd}|dk rt||r|}qn|tjkr|S|tj kr|S||kr|S|tjkr:|tj kr:|S|tj krb|tjkrbt |S|||g|kr||||dt SdS(Ni(RPRQR( R7RPRQRRRRTRRRR!R-R(RRTRPRQRdRRR ((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRNs.')   cC s;|j\}}}tjt||t||d|S(NR=(RTR'RR+(R(R=RdRR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR>mscC s|jjS(N(R>RO(R(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRDqscO s5ddlm}||d|df|dtfS(Ni(Riii(tsympy.functionsRR(R(RTRR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_eval_rewrite_as_Piecewisets( RYRZR[RRRRR>RDR(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs   &  cC s tj|S(sReturn a list of the conjuncts in the expr s. Examples ======== >>> from sympy.logic.boolalg import conjuncts >>> from sympy.abc import A, B >>> conjuncts(A & B) frozenset({A, B}) >>> conjuncts(A | B) frozenset({A | B}) (R't make_args(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt conjuncts{scC s tj|S(sReturn a list of the disjuncts in the sentence s. Examples ======== >>> from sympy.logic.boolalg import disjuncts >>> from sympy.abc import A, B >>> disjuncts(A | B) frozenset({A, B}) >>> disjuncts(A & B) frozenset({A & B}) (R+R(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt disjunctsscC st|ttfS(sa Given a sentence s consisting of conjunctions and disjunctions of literals, return an equivalent sentence in CNF. Examples ======== >>> from sympy.logic.boolalg import distribute_and_over_or, And, Or, Not >>> from sympy.abc import A, B, C >>> distribute_and_over_or(Or(A, And(Not(B), Not(C)))) (A | ~B) & (A | ~C) (t _distributeR'R+(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytdistribute_and_over_ors cC st|ttfS(s Given a sentence s consisting of conjunctions and disjunctions of literals, return an equivalent sentence in DNF. Note that the output is NOT simplified. Examples ======== >>> from sympy.logic.boolalg import distribute_or_over_and, And, Or, Not >>> from sympy.abc import A, B, C >>> distribute_or_over_and(And(Or(Not(A), B), C)) (B & C) | (C & ~A) (RR+R'(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytdistribute_or_over_andsc C sFt|d|drx:|djD]#}t||dr%|}Pq%q%W|dS|dg|djD]}||k ri|^qi}|dtttg|jD]*}|d|||d|df^qSt|d|dr:|dtttg|djD]}||d|df^qS|dSdS(sC Distributes info[1] over info[2] with respect to info[0]. iiiN(RRTRR R(tinfoRtconjRdtrestRRK((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs6>5cC s t||r|S|j|S(s Converts expr to Negation Normal Form. A logical expression is in Negation Normal Form (NNF) if it contains only And, Or and Not, and Not is applied only to literals. If simplify is True, the result contains no redundant clauses. Examples ======== >>> from sympy.abc import A, B, C, D >>> from sympy.logic.boolalg import Not, Equivalent, to_nnf >>> to_nnf(Not((~A & ~B) | (C & D))) (A | B) & (~C | ~D) >>> to_nnf(Equivalent(A >> B, B >> A)) (A | ~B | (A & ~B)) & (B | ~A | (B & ~A)) (tis_nnfR>(RR=((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR>scC s[t|}t|ts|S|r5t|dtSt|rE|St|}t|S(s Convert a propositional logical sentence s to conjunctive normal form. That is, of the form ((A | ~B | ...) & (B | C | ...) & ...) If simplify is True, the expr is evaluated to its simplest CNF form using the Quine-McCluskey algorithm. Examples ======== >>> from sympy.logic.boolalg import to_cnf >>> from sympy.abc import A, B, D >>> to_cnf(~(A | B) | D) (D | ~A) & (D | ~B) >>> to_cnf((A | B) & (A | ~A), True) A | B tcnf(RRRRRtis_cnfteliminate_implicationsR(RR=((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytto_cnfs   cC s[t|}t|ts|S|r5t|dtSt|rE|St|}t|S(s Convert a propositional logical sentence s to disjunctive normal form. That is, of the form ((A & ~B & ...) | (B & C & ...) | ...) If simplify is True, the expr is evaluated to its simplest DNF form using the Quine-McCluskey algorithm. Examples ======== >>> from sympy.logic.boolalg import to_dnf >>> from sympy.abc import A, B, C >>> to_dnf(B & (A | C)) (A & B) | (B & C) >>> to_dnf((A & B) | (A & ~B) | (B & C) | (~B & C), True) A | C tdnf(RRRRRtis_dnfRR(RR=((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytto_dnf s   cC st|}t|rtS|g}x|r|j}|jttfkr|r|j}x'|D]}t||kret SqeWn|j |jq(t|s(t Sq(WtS(sW Checks if expr is in Negation Normal Form. A logical expression is in Negation Normal Form (NNF) if it contains only And, Or and Not, and Not is applied only to literals. If simpified is True, checks if result contains no redundant clauses. Examples ======== >>> from sympy.abc import A, B, C >>> from sympy.logic.boolalg import Not, is_nnf >>> is_nnf(A & B | ~C) True >>> is_nnf((A | ~A) & (B | C)) False >>> is_nnf((A | ~A) & (B | C), False) True >>> is_nnf(Not(A & B) | C) False >>> is_nnf((A >> B) & (B >> A)) False ( RRRRCRR'R+RTR-RR(Rt simplifiedtstackRTR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR.s          cC st|ttS(s( Test whether or not an expression is in conjunctive normal form. Examples ======== >>> from sympy.logic.boolalg import is_cnf >>> from sympy.abc import A, B, C >>> is_cnf(A | B | C) True >>> is_cnf(A & B & C) True >>> is_cnf((A & B) | C) False (t_is_formR'R+(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR\scC st|ttS(sM Test whether or not an expression is in disjunctive normal form. Examples ======== >>> from sympy.logic.boolalg import is_dnf >>> from sympy.abc import A, B, C >>> is_dnf(A | B | C) True >>> is_dnf(A & B & C) True >>> is_dnf((A & B) | C) True >>> is_dnf(A & (B | C)) False (R"R+R'(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRpscC sSt|}|jrtSt||rsxD|jD]9}t|tr^|jdjsktSq2|js2tSq2WtSt|tr|jdjstSnt||stSx|jD]}|jrqnt|tr|jdjstSnt||stSxD|jD]9}t|tr:|jdjsGtSq|jstSqWqWtS(sE Test whether or not an expression is of the required form. i(RRkRRRTR-R(Rt function1t function2tlitR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyR"s>      cC st|dtS(s Change >>, <<, and Equivalent into &, |, and ~. That is, return an expression that is equivalent to s, but has only &, |, and ~ as logical operators. Examples ======== >>> from sympy.logic.boolalg import Implies, Equivalent, eliminate_implications >>> from sympy.abc import A, B, C >>> eliminate_implications(Implies(A, B)) B | ~A >>> eliminate_implications(Equivalent(A, B)) (A | ~B) & (B | ~A) >>> eliminate_implications(Equivalent(A, B, C)) (A | ~C) & (B | ~A) & (C | ~B) R=(R>R(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRscC s6t|tr$t|jdt St|t SdS(sz Returns True if expr is a literal, else False. Examples ======== >>> from sympy import Or, Q >>> from sympy.abc import A, B >>> from sympy.logic.boolalg import is_literal >>> is_literal(A) True >>> is_literal(~A) True >>> is_literal(Q.zero(A)) True >>> is_literal(A + B) True >>> is_literal(Or(A, B)) False iN(RR-RTR(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRsc  svtttttdtddg|D].}tfdtj|D^qDS(s  Takes clauses in CNF format and puts them into an integer representation. Examples ======== >>> from sympy.logic.boolalg import to_int_repr >>> from sympy.abc import x, y >>> to_int_repr([x | y, y], [x, y]) == [{1, 2}, {2}] True icS s+t|tr||jd S||SdS(Ni(RR-RT(RR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt append_symbolsc3 s|]}|VqdS(N((RR(R&R(s2lib/python2.7/site-packages/sympy/logic/boolalg.pys s(tdictRR R RBRRR+R(tclausesRR((R&Rs2lib/python2.7/site-packages/sympy/logic/boolalg.pyt to_int_reprs4 cC s+tdjtttt|dS(sB Return an integer corresponding to the base-2 digits given by ``term``. Parameters ========== term : a string or list of ones and zeros Examples ======== >>> from sympy.logic.boolalg import term_to_integer >>> term_to_integer([1, 0, 0]) 4 >>> term_to_integer('100') 4 Ri(tinttjoinRR R(tterm((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytterm_to_integerscC sCdjtt|tt|p$d}ttt|S(s Return a list of the base-2 digits in the integer, ``k``. Parameters ========== k : int n_bits : int If ``n_bits`` is given and the number of digits in the binary representation of ``k`` is smaller than ``n_bits`` then left-pad the list with 0s. Examples ======== >>> from sympy.logic.boolalg import integer_to_term >>> integer_to_term(4) [1, 0, 0] >>> integer_to_term(4, 6) [0, 0, 0, 1, 0, 0] s {0:0{1}b}i(tformattabsR RR R*(Rtn_bitsRN((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytinteger_to_terms0cc sg|D]}t|^q}t|}t|t rLt| rLdStddgdt|}xQ|D]I}t|}|jtt ||}|r||fVqq|VqqWdS(s Return a generator of all possible configurations of the input variables, and the result of the boolean expression for those values. Parameters ========== expr : string or boolean expression variables : list of variables input : boolean (default True) indicates whether to return the input combinations. Examples ======== >>> from sympy.logic.boolalg import truth_table >>> from sympy.abc import x,y >>> table = truth_table(x >> y, [x, y]) >>> for t in table: ... print('{0} -> {1}'.format(*t)) [0, 0] -> True [0, 1] -> True [1, 0] -> False [1, 1] -> True >>> table = truth_table(x | y, [x, y]) >>> list(table) [([0, 0], False), ([0, 1], True), ([1, 0], True), ([1, 1], True)] If input is false, truth_table returns only a list of truth values. In this case, the corresponding input values of variables can be deduced from the index of a given output. >>> from sympy.logic.boolalg import integer_to_term >>> vars = [y, x] >>> values = truth_table(x >> y, vars, input=False) >>> values = list(values) >>> values [True, False, True, True] >>> for i, value in enumerate(values): ... print('{0} -> {1}'.format(list(zip( ... vars, integer_to_term(i, len(vars)))), value)) [(y, 0), (x, 0)] -> True [(y, 0), (x, 1)] -> False [(y, 1), (x, 0)] -> True [(y, 1), (x, 1)] -> True Niitrepeat( RRRRRRBRtxreplaceR'R (Rt variablestinputtvttableR,tvalue((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt truth_table5s2   cC s^d}xQtt||D]:\}\}}||kr|dkrO|}qVdSqqW|S(sk Checks if a pair of minterms differs by only one bit. If yes, returns index, else returns -1. i(RR (tminterm1tminterm2tindexRKRXR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt _check_pairxs(    cC ssg}x`t|D]R\}}|dkrE|jt||q|dkr|j||qqWt|S(sh Converts a term in the expansion of a function from binary to its variable form (for SOP). ii(RRR-R'(tmintermR4ttempRXR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_convert_to_varsSOPs  cC ssg}x`t|D]R\}}|dkrE|jt||q|dkr|j||qqWt|S(sh Converts a term in the expansion of a function from binary to its variable form (for POS). ii(RRR-R+(tmaxtermR4R?RXR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_convert_to_varsPOSs  c C sg}ttt|}xt|d D]\}}xt||dD]q\}}t||}|dkrPd||<|||d<|}d||<||kr|j|qqPqPWq/W|jgg|D]} | dk r| ^qD]}||^q|S(s Reduces a set of minterms, if possible, to a simplified set of minterms with one less variable in the terms using QM method. iiiN(RR RBRR=R!RR( ttermstsimplified_termsttodoRXttitj_ittjR<tnewtermt_((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_simplified_pairss!   =cC sAx:t|D],\}}|dkr |||kr tSq WtS(sq Return True if a binary term is satisfied by the given term. Used for recognizing prime implicants. i(RRR(R>R,RXRK((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt _compare_termscC st|rgtt|D]}dgt|^q}xWt|D]I\}}x:t|D],\}}t||rdd|||scs s!|]\}}||kVqdS(N((RRdR((s2lib/python2.7/site-packages/sympy/logic/boolalg.pys sN(RBR RRLRR!RR (tl1RCtnt dommatrixtprimeitprimettermiR,tndprimeimplicantstndtermst oldndtermstoldndprimeimplicantstrowitrowRJRXtrow2itrow2tcoliRdtcoltcol2itcol2((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_rem_redundancysT 2 9 ,-9 *9<c C sdg}t|}xK|D]C}t|trG|jt||qt|trt|}x!|jD]}|j|qoWxt ddgdt|D]L}tt ||}|j ||jg|D]} || ^qqWqt|tt frPt||kr:t dj||n|jt|qtdqW|S(NiiR2sLEach term must contain {} bits as there are {} variables (or be an integer).s2A term list can only contain lists, ints or dicts.(RBRR*RRR'RtkeysRRR tupdateRRR.R#( t inputlistR4tbinlisttbitstvalt nonspecvarsRtttdR6((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_input_to_binlists(   % + c C sg|D]}t|^q}|gkr/tSt||}t|pJg|}x-|D]%}||krZtd|qZqZWd}||}x"||kr|}t|}qWt||}tg|D]}t||^qS(sq The SOPform function uses simplified_pairs and a redundant group- eliminating algorithm to convert the list of all input combos that generate '1' (the minterms) into the smallest Sum of Products form. The variables must be given as the first argument. Return a logical Or function (i.e., the "sum of products" or "SOP" form) that gives the desired outcome. If there are inputs that can be ignored, pass them as a list, too. The result will be one of the (perhaps many) functions that satisfy the conditions. Examples ======== >>> from sympy.logic import SOPform >>> from sympy import symbols >>> w, x, y, z = symbols('w x y z') >>> minterms = [[0, 0, 0, 1], [0, 0, 1, 1], ... [0, 1, 1, 1], [1, 0, 1, 1], [1, 1, 1, 1]] >>> dontcares = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 1]] >>> SOPform([w, x, y, z], minterms, dontcares) (y & z) | (z & ~w) The terms can also be represented as integers: >>> minterms = [1, 3, 7, 11, 15] >>> dontcares = [0, 2, 5] >>> SOPform([w, x, y, z], minterms, dontcares) (y & z) | (z & ~w) They can also be specified using dicts, which does not have to be fully specified: >>> minterms = [{w: 0, x: 1}, {y: 1, z: 1, x: 0}] >>> SOPform([w, x, y, z], minterms) (x & ~w) | (y & z & ~x) Or a combination: >>> minterms = [4, 7, 11, [1, 1, 1, 1]] >>> dontcares = [{w : 0, x : 0, y: 0}, 5] >>> SOPform([w, x, y, z], minterms, dontcares) (w & y & z) | (x & y & z) | (~w & ~y) References ========== .. [1] en.wikipedia.org/wiki/Quine-McCluskey_algorithm s#%s in minterms is also in dontcaresN( RRRiRR!RKR_R+R@( R4tmintermst dontcaresR6Rhtoldtnewt essentialRK((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytSOPforms6    c C sPg|D]}t|^q}|gkr/tSt||}t|pJg|}x-|D]%}||krZtd|qZqZWg}xZtddgdt|D]:}t|}||kr||kr|j|qqWd}||}x"||kr|}t |}qWt ||} t g| D]} t | |^q4S(sj The POSform function uses simplified_pairs and a redundant-group eliminating algorithm to convert the list of all input combinations that generate '1' (the minterms) into the smallest Product of Sums form. The variables must be given as the first argument. Return a logical And function (i.e., the "product of sums" or "POS" form) that gives the desired outcome. If there are inputs that can be ignored, pass them as a list, too. The result will be one of the (perhaps many) functions that satisfy the conditions. Examples ======== >>> from sympy.logic import POSform >>> from sympy import symbols >>> w, x, y, z = symbols('w x y z') >>> minterms = [[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1], ... [1, 0, 1, 1], [1, 1, 1, 1]] >>> dontcares = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 1]] >>> POSform([w, x, y, z], minterms, dontcares) z & (y | ~w) The terms can also be represented as integers: >>> minterms = [1, 3, 7, 11, 15] >>> dontcares = [0, 2, 5] >>> POSform([w, x, y, z], minterms, dontcares) z & (y | ~w) They can also be specified using dicts, which does not have to be fully specified: >>> minterms = [{w: 0, x: 1}, {y: 1, z: 1, x: 0}] >>> POSform([w, x, y, z], minterms) (x | y) & (x | z) & (~w | ~x) Or a combination: >>> minterms = [4, 7, 11, [1, 1, 1, 1]] >>> dontcares = [{w : 0, x : 0, y: 0}, 5] >>> POSform([w, x, y, z], minterms, dontcares) (w | x) & (y | ~w) & (z | ~y) References ========== .. [1] en.wikipedia.org/wiki/Quine-McCluskey_algorithm s#%s in minterms is also in dontcaresiiR2N( RRRiRRRBRRR!RKR_R'RB( R4RjRkR6RhtmaxtermsRgRlRmRnRK((s2lib/python2.7/site-packages/sympy/logic/boolalg.pytPOSformgs(7   %  cC s3t|ts|hStjd|jDS(sHelper to find logical predicates in BooleanFunctions. A logical predicate is defined here as anything within a BooleanFunction that is not a BooleanFunction itself. cs s|]}t|VqdS(N(t_find_predicates(RRX((s2lib/python2.7/site-packages/sympy/logic/boolalg.pys s(RRRRRSRT(R((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRrsc C s|dkrtdnt|}|rt|}ddlm}g|D]}||^qP}|jtt||}nt |t s|St|}| rt |dkr|St |ddt \}}||}g} g|D]} | t krd nd ^q}xdtd d gd t |D]D} |jtt|| t kr=| j|t| q=q=Wt | d t |d k} |dks|d kr| rt|| St|| S(sg This function simplifies a boolean function to its simplified version in SOP or POS form. The return type is an Or or And object in SymPy. Parameters ========== expr : string or boolean expression form : string ('cnf' or 'dnf') or None (default). If 'cnf' or 'dnf', the simplest expression in the corresponding normal form is returned; if None, the answer is returned according to the form with fewest args (in CNF by default). deep : boolean (default True) Indicates whether to recursively simplify any non-boolean functions contained within the input. force : boolean (default False) As the simplifications require exponential time in the number of variables, there is by default a limit on expressions with 8 variables. When the expression has more than 8 variables only symbolical simplification (controlled by ``deep``) is made. By setting force to ``True``, this limit is removed. Be aware that this can lead to very long simplification times. Examples ======== >>> from sympy.logic import simplify_logic >>> from sympy.abc import x, y, z >>> from sympy import S >>> b = (~x & ~y & ~z) | ( ~x & ~y & z) >>> simplify_logic(b) ~x & ~y >>> S(b) (z & ~x & ~y) | (~x & ~y & ~z) >>> simplify_logic(_) ~x & ~y RRsform can be cnf or dnf onlyi(R=icS s|ttfkS(N(RR(RK((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRRRiiR2iN(NRR(R!RRRrtsympy.simplify.simplifyR=R3R'R RRRBRRRRRRoRq( RtformtdeeptforceR4R=R6RNRt truthtableRXRgtbig((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyRs0+   !  +%$  c C s|j}ttt|g|D]}dgd^q}x|jD]}|jrn||dcd7>> from sympy.logic.boolalg import _finger as finger >>> from sympy import And, Or, Not >>> from sympy.abc import a, b, x, y >>> eq = Or(And(Not(y), a), And(Not(y), b), And(x, y)) >>> dict(finger(eq)) {(0, 0, 1, 0, 2): [x], (0, 0, 1, 0, 3): [a, b], (0, 0, 1, 2, 2): [y]} >>> dict(finger(x & ~y)) {(0, 1, 0, 0, 0): [y], (1, 0, 0, 0, 0): [x]} The equation must not have more than one level of nesting: >>> dict(finger(And(Or(x, y), y))) {(0, 0, 1, 0, 2): [x], (1, 0, 1, 0, 2): [y]} >>> dict(finger(And(Or(x, And(a, x)), y))) Traceback (most recent call last): ... NotImplementedError: unexpected level of nesting So y and x have unique fingerprints, but a and b do not. iiics s|]}t|tVqdS(N(RR-(Rtai((s2lib/python2.7/site-packages/sympy/logic/boolalg.pys 4 siiisunexpected level of nesting(RAR'RR RTRVRRBtsumR9RRtitertitemsRR( teqRtfiRhRdtoRytinvRR6((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyt_finger s&! 5  &   %cC sDd}t|}t|}|||}|r@||fS|S(s Return the simplified version of bool1, and the mapping of variables that makes the two expressions bool1 and bool2 represent the same logical behaviour for some correspondence between the variables of each. If more than one mappings of this sort exist, one of them is returned. For example, And(x, y) is logically equivalent to And(a, b) for the mapping {x: a, y:b} or {x: b, y:a}. If no such mapping exists, return False. Examples ======== >>> from sympy import SOPform, bool_map, Or, And, Not, Xor >>> from sympy.abc import w, x, y, z, a, b, c, d >>> function1 = SOPform([x, z, y],[[1, 0, 1], [0, 0, 1]]) >>> function2 = SOPform([a, b, c],[[1, 0, 1], [1, 0, 0]]) >>> bool_map(function1, function2) (y & ~z, {y: a, z: b}) The results are not necessarily unique, but they are canonical. Here, ``(w, z)`` could be ``(a, d)`` or ``(d, a)``: >>> eq = Or(And(Not(y), w), And(Not(y), z), And(x, y)) >>> eq2 = Or(And(Not(c), a), And(Not(c), d), And(b, c)) >>> bool_map(eq, eq2) ((x & y) | (w & ~y) | (z & ~y), {w: a, x: b, y: c, z: d}) >>> eq = And(Xor(a, b), c, And(c,d)) >>> bool_map(eq, eq.subs(c, x)) (c & d & (a | b) & (~a | ~b), {a: a, b: b, c: d, d: x}) cS s|j|jkrdSt|jt|jkr8dS|jrLi||6St|}t|}t|t|krtSi}x{|jD]m}||krtSt||t||krtSx0t||D]\}}|||||RRRRRRR"RRR)R-R!R1R9R=R@RBRKRLR_RiRoRqRrRRRRRR(((s2lib/python2.7/site-packages/sympy/logic/boolalg.pyts" "r4uC     s?{s"OIt       ! ! .   1      C     =  I O I 8 T #