o o h@sdZddlmZddlmZmZmZmZddlm Z ddl m Z ddl m Z ddlmZddlmZmZdd lmZmZdd lmZmZdd lmZdd lmZdd lmZmZddl m!Z!ddl"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*ddZ+eGddde Z,Gddde,Z-Gddde-edZ.Gddde-edZ/e.Z0e/Z1e0e_0e1e_1dde#e2<Gdd d ee,Z3Gd!d"d"ee3Z4Gd#d$d$ee3Z5Gd%d&d&e3Z6Gd'd(d(e3Z7Gd)d*d*e3Z8Gd+d,d,e3Z9Gd-d.d.e3Z:Gd/d0d0e3Z;Gd1d2d2e3Zd7d8Z?d9d:Z@d;d<ZAd=d>ZBd?d@ZCdAdBZDddDdEZEddFdGZFddIdJZGddKdLZHdMdNZIddOdPZJdQdRZKdSdTZLdUdVZMdWdXZNdYdZZOd[d\ZPd]d^ZQe(ZRdd_d`ZSdadbZTdcddZUdedfZVdgdhZWdidjZXdkdlZYdmdnZZdodpZ[dqdrZ\ddtduZ]dvdwZ^ddxdyZ_dzd{Z`d|d}Zad~dZbddZcddZdddZedddZfddZgddZhddZi s sdddZjddZkddZle ddZme ddZne ddZoe ddZpddZqe4e5e7e8e9e6e:e=fZrddZsdsS)z" Boolean algebra module for SymPy ) defaultdict)chain combinationsproduct permutations)Add)Basic)cacheit)Tuple)sympify_method_argssympify_return) Application Derivative) BooleanKind NumberKind)Number) LatticeOp) SingletonS)ordered)_sympy_converter_sympifysympify)siftibin) filldedentcCsfddlm}|dkr tS|dkrtSt||r&|j}|dur |S|r$tStSt|tr-|Std|)aLike ``bool``, return the Boolean value of an expression, e, which can be any instance of :py:class:`~.Boolean` or ``bool``. Examples ======== >>> from sympy import true, false, nan >>> from sympy.logic.boolalg import as_Boolean >>> from sympy.abc import x >>> as_Boolean(0) is false True >>> 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`. >>> as_Boolean(nan) Traceback (most recent call last): ... TypeError: expecting bool or Boolean, not `nan`. r)SymbolTFNz$expecting bool or Boolean, not `%s`.)sympy.core.symbolrtruefalse isinstanceis_zeroBoolean TypeError)erzr&g/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/logic/boolalg.py as_Booleans     r(c@seZdZdZdZeZedgeddZ e Z edgeddZ e Z dd Z edged d Zedged d ZeZeZedgeddZeZddZdddZddZeddZddZdS)r"zDA Boolean object is an object for which logic operations make sense.r&)otherr"cC t||SNAndselfr)r&r&r'__and__H zBoolean.__and__cCr*r+)Orr.r&r&r'__or__Nr1zBoolean.__or__cCst|S)zOverloading for ~Notr/r&r&r' __invert__TszBoolean.__invert__cCr*r+Impliesr.r&r&r' __rshift__Xr1zBoolean.__rshift__cCs t||Sr+r8r.r&r&r' __lshift__\r1zBoolean.__lshift__cCr*r+)Xorr.r&r&r'__xor__cr1zBoolean.__xor__cCsXddlm}ddlm}||s||rtd||ko+|tt|| S)a 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 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 r) satisfiable Relationalzhandling of relationals) sympy.logic.inferencer>sympy.core.relationalr@hasNotImplementedErroratomsr5 Equivalent)r/r)r>r@r&r&r'equalsis  zBoolean.equalsTcC|Sr+r&r/simplifyr&r&r'to_nnfzBoolean.to_nnfc Csddlm}ddlm}|j}t|dkrb|}|jtur^i}| |D]%}|||dvrJ| }|t j t j t jfvrD||||<q%ttdq%||}|j|jkrZ|S| S| Std)a Rewrites Boolean expression in terms of real sets. Examples ======== >>> 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)) r) periodicityr?)rNz as_set is not implemented for relationals with periodic solutions zGSorry, as_set has not yet been implemented for multivariate expressions)sympy.calculus.utilrMrBr@ free_symbolslenpopkindrrE _eval_as_setrEmptySet UniversalSetReals as_relationalrDrsubsfuncas_set) r/rMr@freexrepsrsnewr&r&r'r[s*      zBoolean.as_setcs.ddlmmtjfdd|jDS)NrEqNecs,g|]}|js|jst|fr|jqSr&) is_Boolean is_Symbolr binary_symbols.0irbr&r' s  z*Boolean.binary_symbols..)rBrcrdsetunionargsr6r&rbr'rgszBoolean.binary_symbolscCs2ddlm}|||}|durtS|durtSdS)Nr)askTF)sympy.assumptionsrorr)r/ assumptionsroretr&r&r' _eval_refines  zBoolean._eval_refineNT)__name__ __module__ __qualname____doc__ __slots__rrSr NotImplementedr0__rand__r3__ror__r7r:r; __rrshift__ __rlshift__r=__rxor__rGrKr[propertyrgrsr&r&r&r'r"@s4           1  r"c@seZdZdZdZdZdZddZddZe dd Z dd d Z e Z e Z e Ze Ze Ze Ze Ze Ze Ze Ze Ze Ze Zd dZeZeZeZddZd S) BooleanAtomzQ Base class of :py:class:`~.BooleanTrue` and :py:class:`~.BooleanFalse`. T cOrHr+r&r/akwr&r&r'rJzBooleanAtom.simplifycOrHr+r&rr&r&r'expandrzBooleanAtom.expandcCrHr+r&r6r&r&r' canonicalrLzBooleanAtom.canonicalNcCstd)Nz(BooleanAtom not allowed in this context.)r#r.r&r&r'_noopzBooleanAtom._noopcC ttdNz A Boolean argument can only be used in Eq and Ne; all other relationals expect real expressions. r#rr.r&r&r'__lt__ zBooleanAtom.__lt__cKrHr+r&)r/kwargsr&r&r'_eval_simplifyrzBooleanAtom._eval_simplifyr+)rurvrwrxreis_Atom _op_priorityrJrrrr__add____radd____sub____rsub____mul____rmul____pow____rpow__ __truediv__ __rtruediv____mod____rmod__ _eval_powerr__le____gt____ge__rr&r&r&r'rs8   rcDeZdZdZddZddZfddZedd Zd d Z Z S) BooleanTruea 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: Do not 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 # doctest: +SKIP (False, -2) >>> true >> true, True >> True (True, 0) See Also ======== sympy.logic.boolalg.BooleanFalse cCdSNTr&r6r&r&r'__bool__QrzBooleanTrue.__bool__cCtdSrhashr6r&r&r'__hash__TrzBooleanTrue.__hash__cs$|durdS|dur dSt|SNTFsuper__eq__r. __class__r&r'rW  zBooleanTrue.__eq__cCtSr+)rr6r&r&r'negated^rLzBooleanTrue.negatedcCtjS)z Rewrite logic operators and relationals in terms of real sets. Examples ======== >>> from sympy import true >>> true.as_set() UniversalSet )rrVr6r&r&r'r[bs zBooleanTrue.as_set rurvrwrxrrrrrr[ __classcell__r&r&rr'rsS  r) metaclasscr) BooleanFalsea 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 the notes section 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 # doctest: +SKIP (True, -1) >>> false >> false, False >> False (True, 0) See Also ======== sympy.logic.boolalg.BooleanTrue cCrNFr&r6r&r&r'rrzBooleanFalse.__bool__cCrrrr6r&r&r'rrzBooleanFalse.__hash__cs$|durdS|dur dSt|Srrr.rr&r'rrzBooleanFalse.__eq__cCrr+)rr6r&r&r'rrLzBooleanFalse.negatedcCr)z Rewrite logic operators and relationals in terms of real sets. Examples ======== >>> from sympy import false >>> false.as_set() EmptySet )rrUr6r&r&r'r[s zBooleanFalse.as_setrr&r&rr'rqs*  rcCs |rtStSr+)rrr]r&r&r' rc@seZdZdZdZddZddZddZeZeZ eZ e d d Z dd d Z dd dZe ddZe ddZddZddZdS)BooleanFunctionzBoolean function is a function that lives in a boolean space It is used as base class for :py:class:`~.And`, :py:class:`~.Or`, :py:class:`~.Not`, etc. Tc sDt|}t|ts|jdiS|jfdd|jD}t|S)Ncg|] }|jdiqSr&rJrirrr&r'rkz2BooleanFunction._eval_simplify..r&)simplify_univariater rrJrZrnsimplify_logic)r/rrvr&rr'rs  zBooleanFunction._eval_simplifycKsddlm}||fi|S)Nrr)sympy.simplify.simplifyrJ)r/rrJr&r&r'rJs zBooleanFunction.simplifycCrrrr.r&r&r'rrzBooleanFunction.__lt__cGsdd|DS)NcSg|]}t|qSr&)r(rhr&r&r'rkz=BooleanFunction.binary_check_and_simplify..r&)r/rnr&r&r'binary_check_and_simplifysz)BooleanFunction.binary_check_and_simplifycC|j|jd|iS)NrJ)_to_nnfrnrIr&r&r'rKzBooleanFunction.to_nnfcCrNdeep)_to_anfrnr/rr&r&r'to_anfrzBooleanFunction.to_anfcOs|dd}t}|D]6}t|s||}|r>> from sympy.abc import x, y >>> from sympy 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 produce different results if ``a`` and ``b`` are integers. >>> And(x, y).subs(x, 1) y NcCsrtj|}t|t}g}t}t|D]"}|jr1|j}||vr!q|j j|vr,t gS| || |q|Sr+) rrr_new_args_filterr-rlr is_Relationalrrrrrrrnnewargsrelr]cr&r&r'r@s       zAnd._new_args_filterc Cg}d}|jD]+}z|||}Wnty |dur|}Yqw|dkr)tS|dkr2||q|dur=|||t|trWt|j}||rWt||}| ||j |S)NFT) rnrYr#rrr r-rlissubsetrrZr/oldrarnbadrjold_setr&r&r' _eval_subsR.          zAnd._eval_subsc sddlmmddlm}tjdi|}t|ts|St |j fdddd\}}|s0|St |fdddd\}}|d }|rB|d } ii} t t d d |Dd d} g}g} d| vr| dD]z\} } | }| j |ks{|| jjvr|vrz.|t| j | j dd|\}}| || |}||| || kr|} n|| WqhWn tyYnw|vr|| ||qh| j |kr|| jjvr| j|<|| qh| | qhtt}| D]}| |D]\}} | } | j}|t||| fqq|} d| vsc| D]}|dd | |Dqfdd | D} fdd |D}|jdd || |D|}t}t}t|||t|dS)Nr)Equalityr@) linear_coeffsc t|Sr+r rjr?r&r'rx z$And._eval_simplify..Tbinarycrr+rr)rr&r'r|rmeasureratiocSsg|]}|j|fqSr&)rPrhr&r&r'rks z&And._eval_simplify..cSs t|dSNr)rQrr&r&r'rrrNFrcSsg|]\}}|qSr&r&)rifr$r&r&r'rkrcg|]}|qSr&rYrieir^r&r'rkcrr&rrr r&r'rkr cSg|]}|jqSr&rrhr&r&r'rk)threeterm_patternsr&)rBrr@sympy.solvers.solvesetrrrr r-rrnrrRlhsrhsrPrrZr ValueErrorrYrlistxreplacerQextend_simplify_patterns_and_simplify_patterns_and3"_apply_patternbased_simplificationr)r/rrrRelnonReleqsr)rrsifted nonlineqsr\r$r]mbenewresiftedkrpatternsrr)rr@r^r'rns            zAnd._eval_simplifycC ddlm}|dd|jDS)Nr) IntersectioncSg|]}|qSr&r[rirr&r&r'rkrz$And._eval_as_set..)sympy.sets.setsr%rn)r/r%r&r&r'rT zAnd._eval_as_setcOtdd|jDS)NcSrr&r4r(r&r&r'rkrz,And._eval_rewrite_as_Nor..)Norrnr/rnrr&r&r'_eval_rewrite_as_NorzAnd._eval_rewrite_as_NorTcCs"|rtj|jd|i}t|S|Sr)r-rrndistribute_xor_over_and)r/rresultr&r&r'rsz And.to_anfrt)rurvrwrxrrridentitynargsrrrrrTr.rrr&r&rr'r- s  Dr-csVeZdZdZeZeZeddZ ddZ ddZ dd Z fd d Z dd dZZS)r2aM Logical OR function It evaluates its arguments in order, returning true immediately when an argument is true, and false if they are all false. Examples ======== >>> from sympy.abc import x, y >>> from sympy 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 cszg}g}tj|}|D]+}|jr1|j}||vrq |jjtfdd|Dr,tgS||||q t |t S)Nc3s|]}|kVqdSr+r&rir_ncr&r' z&Or._new_args_filter..) rrrrranyrrrrr2rr&r5r'rs     zOr._new_args_filterc Crr) rnrYr#rrr r2rlrrrZrr&r&r'rrz Or._eval_subscCr$)Nr)UnioncSr&r&r'r(r&r&r'rk rz#Or._eval_as_set..)r)r:rn)r/r:r&r&r'rT r*zOr._eval_as_setcOr+)NcSrr&r4r(r&r&r'rkrz,Or._eval_rewrite_as_Nand..)Nandrnr-r&r&r'_eval_rewrite_as_Nandr/zOr._eval_rewrite_as_Nandc sddlm}m}m||}|r'fdd|D}|jdi|Stjdi|}t|t s7|St }t |||dt S)Nr)LeGerccs&i|]}||j|j|jqSr&)rZrrstrictrhrcr/r&r' s z%Or._eval_simplify..rr&) rBr=r>rcrErrrr r2_simplify_patterns_orrr)r/rr=r>leger^rr#rr@r'rs   zOr._eval_simplifyTcsbtdtjd}fdd|D}t|}dd|D}fdd|D}tt|ddiS)NrNc3s|] }tj|VqdSr+)rrn)rijr6r&r'r7#zOr.to_anf..css|]}t|VqdSr+r,r(r&r&r'r7%r8c3s$|] }r t|dn|VqdS)rN)rrir]rr&r'r7&"rF)rangerQrnr from_iterabler<r)r/rrnr&)rr/r'r!s  z Or.to_anfrt)rurvrwrxrrrr2rrrrTr<rrrr&r&rr'r2s  r2c@s<eZdZdZdZeddZddZd ddZd d d Z d S) r5a Logical Not function (negation) Returns ``true`` if the statement is ``false`` or ``False``. Returns ``false`` if the statement is ``true`` or ``True``. Examples ======== >>> from sympy 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``. - As of Python 3.12, the bitwise not operator ``~`` used on a Python ``bool`` is deprecated and will emit a warning. >>> from sympy import true >>> ~True # doctest: +SKIP -2 >>> ~true False TcCs>t|ts |dvr|r tStS|jr|jdS|jr|jSdS)NTFr)r rrris_Notrnrr)rrr&r&r'eval^s  zNot.evalcCs|jdtjS)z 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) r)rnr[ complementrrWr6r&r&r'rThs zNot._eval_as_setc sbt|r|S|jd}|j|j}}|tkr#tjdd|Dd|iS|tkr4tjdd|Dd|iS|tkrF|\}}tj|t||dS|tkr[tjt|tdd|D|dS|t krg}t dt |dd D]}t ||D]fd d|D} | t| qrqktj|d|iS|tkr|\}}} tjt|t| tt|t||dStd |) NrcSrr&r4r(r&r&r'rkrzNot.to_nnf..rJcSrr&r4r(r&r&r'rkrrcSrr&r4r(r&r&r'rkrrNc g|] }|vr t|n|qSr&r4rir`negr&r'rk z!Illegal operator %s in expression)rrnrZr-r2rr9r5rFr<rHrQrrITEr) r/rJexprrZrnrrr1rjclauserr&rQr'rKvs6  ( z Not.to_nnfcCstjt|jd|dS)Nrr)r<rrrnrr&r&r'rsz Not.to_anfNrt) rurvrwrxrKrrLrTrKrr&r&r&r'r5*s1  $r5cs`eZdZdZddfdd ZeeddZddd Zd d Z d d Z ddZ ddZ Z S)r<ac 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 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 T)rcst}tj|g|Ri|}|jD]:}t|ts|dvr$|r#t}nqt|tr>|jD]}||vr7| |n| |q,q||vrH| |q| |qdd|D}d} g} t |D]4\} \} } }t | dt |D]}||dd\}}||kr| } n|| krnqmq]| | |fq]| rt|vr| tn| t| D]\}}| || |qt |dkrtSt |dkr|Sd|vr|r| dtt|Stt||_t||_|S) NrJcSs"g|] }|jr||j|jjfqSr&)rrrr4r&r&r'rkszXor.__new__..FrNrNrT)rlr__new___argsr rrr<rnremover enumeraterHrQrrrRr5tupler frozenset_argset)rrrnrrobjrrroddrYrjr_rr6rDrjcjrrr&r'rWs^              z Xor.__new__cCtt|jSr+r[rr]r6r&r&r'rnzXor.argscsdg}tdt|jddD]}t|j|D]fdd|jD}|t|qq tj|d|iS)NrrNrNcrOr&r4rPrQr&r'rkrSzXor.to_nnf..rJ)rHrQrnrrr2r-r)r/rJrnrjrVr&rQr'rKsz Xor.to_nnfc$j}tfddtt|DS)Ncg|]}t|jqSr&)_convert_to_varsSOPrnrFr6r&r'rkz+Xor._eval_rewrite_as_Or..)rnr2_get_odd_parity_termsrQr/rnrrr&r6r'_eval_rewrite_as_Or  zXor._eval_rewrite_as_Orcre)Ncrfr&)_convert_to_varsPOSrnrFr6r&r'rk rhz,Xor._eval_rewrite_as_And..)rnr-_get_even_parity_termsrQrjr&r6r'_eval_rewrite_as_And rlzXor._eval_rewrite_as_Andc sH|jfdd|jD}|}t|ts|St}t||ddS)Ncrrrrrr&r'rkrz&Xor._eval_simplify..r)rZrnrr r<_simplify_patterns_xorr)r/rrr#r&rr'rs zXor._eval_simplifycCsJt|tr!t|j}||jr#t|j|}|||j|SdSdSr+)r r<rlrnrrrZ)r/rrarrnr&r&r'rs     zXor._eval_subsrt)rurvrwrxrWrr rnrKrkrorrrr&r&rr'r<s'2   r<c@eZdZdZeddZdS)r;a 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 tt|Sr+)r5r-rrnr&r&r'rL> z Nand.evalNrurvrwrxrrLr&r&r&r'r;&sr;c@rq)r,a* 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) cGrrr+)r5r2rsr&r&r'rL`rtzNor.evalNrur&r&r&r'r,Csr,c@rq)Xnora  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 cGrrr+)r5r<rsr&r&r'rLrtz Xnor.evalNrur&r&r&r'rvesrvc@s0eZdZdZeddZd ddZd ddZd S) r9a  Logical implication. A implies B is equivalent to if A then B. Mathematically, it is written as `A \Rightarrow B` and is equivalent to `\neg A \vee B` or ``~A | 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 cGsz#g}|D]}t|ts|dvr|t|q||q|\}}Wnty6tdt|t|fw|dvs?|dvrFtt||S||krLt S|j re|j re|j |j krZt S|j j |j krc|SdSt j|g|RS)NrrNz:%d operand(s) used for an Implies (pairs are required): %srJ)r rrboolrrQstrr2r5rrrrrrW)rrnrr]ABr&r&r'rLs2     z Implies.evalTcCs|j\}}tjt|||dSNr)rnr2rr5)r/rJrrr&r&r'rKs zImplies.to_nnfcCs"|j\}}tjt|t|||dS)Nr)rnr<rrr-r/rrrr&r&r'rs zImplies.to_anfNrt)rurvrwrxrrLrKrr&r&r&r'r9s 0  r9csDeZdZdZfddZeeddZd ddZd d d Z Z S) rFa 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. For two arguments, this is equivalent to :py:class:`~.Xnor`. Examples ======== >>> from sympy.logic.boolalg import Equivalent, And >>> from sympy.abc import x >>> Equivalent(False, False, False) True >>> Equivalent(True, False, False) False >>> Equivalent(x, And(x, True)) True csddlm}dd|D}t|}|D]}t|ts|dvr*|||t|qg}|D]}t||rA|||j |j j fq/g}t |D]4\} \}} } t | dt |D]#} || dd\} }|| krntS|| kr{||| fnqXqH|D]\}}|||||dqt |dkrtSd|vr|dt|Sd |vr|d td d|DSt|}t||}||_|S) Nrr?cSrr&)rr(r&r&r'rkrz&Equivalent.__new__..rJrNrNTFcSrr&r4r(r&r&r'rkr)rBr@rlr rdiscardrrxrrrrZrHrQrrYrr-r\rrWr])rrnoptionsr@rr]rr_rYrjrr6rDr`rarrrXr^rr&r'rWsP           zEquivalent.__new__cCrbr+rcr6r&r&r'rnrdzEquivalent.argsTcCshg}t|j|jddD]\}}|tt||q |tt|jd|jdtj|d|iS)NrNrrJ)ziprnrr2r5r-r)r/rJrnrrr&r&r'rKs  zEquivalent.to_nnfcCs6t|j}tdd|jD}t|}tj|||dS)NcSsg|] }tt|ddqS)Fr)rr5r(r&r&r'rk'rz%Equivalent.to_anf..r)r-rnr0r<rr}r&r&r'r%s zEquivalent.to_anfrt) rurvrwrxrWrr rnrKrrr&r&rr'rFs )  rFc@s>eZdZdZddZeddZdddZd d Zd d Z d S)rTaC 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. From a logic gate perspective, ITE corresponds to a 2-to-1 multiplexer, where A is the select signal. 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 Os<ddlm}m}t|dkrtd|\}}}t|||frutt||f\}}tj dd||fD}tt|j |dkrt|} |j t urJ|j }n!|j t urS|j }n|j tur^t|j }n |j turit|j }nt}t| |rtt|}n t|||\}}}d} |dd r||||} | durtj||||d d } | S) Nrrbzexpecting exactly 3 argscSr r&)rgrhr&r&r'rk[r zITE.__new__..rNrTFr)rBrcrdrQrr mapr(rlrmrnrrrrr5rrrrLrW) rrnrrcrdrrrbin_syms_arr&r&r'rWPs<           z ITE.__new__cGsddlm}m}|\}}}t|||frK|}t|jvr'|jtur#|jn|j}nt|jvr<|jtur6t |jnt |j}nd}|durKt||rKt |}|turQ|S|turW|S||kr]|S|turg|turg|S|turs|turst |S|||g|kr||||ddSdS)NrrbFr) rBrcrdr rrnrrrr5)rrnrcrdrrrrr&r&r'rLvs0    zITE.evalTcCs,|j\}}}tjtt||t|||dSr|)rnr-rr2r5)r/rJrrrr&r&r'rKs  z ITE.to_nnfcCs |Sr+)rKr[r6r&r&r'rTrzITE._eval_as_setcOs*ddlm}||d|df|ddfS)NrrrNrNT)rr)r/rnrrr&r&r'_eval_rewrite_as_Piecewises zITE._eval_rewrite_as_PiecewiseNrt) rurvrwrxrWrrLrKrTrr&r&r&r'rT,s#&   rTc@rq) Exclusivea True if only one or no argument is true. ``Exclusive(A, B, C)`` is equivalent to ``~(A & B) & ~(A & C) & ~(B & C)``. For two arguments, this is equivalent to :py:class:`~.Xor`. Examples ======== >>> from sympy.logic.boolalg import Exclusive >>> Exclusive(False, False, False) True >>> Exclusive(False, True, False) True >>> Exclusive(False, True, True) False cGs4g}t|dD]\}}|tt||qt|S)NrN)rrr5r-)rrnand_argsrrr&r&r'rLszExclusive.evalNrur&r&r&r'rsrcC t|S)aReturn a list of the conjuncts in ``expr``. 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- make_argsrUr&r&r' conjuncts rcCr)aReturn a list of the disjuncts in ``expr``. 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}) r2rrr&r&r' disjunctsrrcCt|ttfS)ai Given a sentence ``expr`` 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) ) _distributer-r2rr&r&r'distribute_and_over_orsrcCr)a Given a sentence ``expr`` 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) )rr2r-rr&r&r'distribute_or_over_andrcCr)a Given a sentence ``expr`` consisting of conjunction and exclusive disjunctions of literals, return an equivalent exclusive disjunction. Note that the output is NOT simplified. Examples ======== >>> from sympy.logic.boolalg import distribute_xor_over_and, And, Xor, Not >>> from sympy.abc import A, B, C >>> distribute_xor_over_and(And(Xor(Not(A), B), C)) (B & C) ^ (C & ~A) )rr<r-rr&r&r'r0rr0cstddrGdjD] }t|dr|nqdSdfdddjDdtttfddjDddiStddrhdtttfd ddjDddiSdS) zO Distributes ``info[1]`` over ``info[2]`` with respect to ``info[0]``. rrNrNcsg|]}|ur|qSr&r&r)conjr&r'rk$z_distribute..cs(g|]}d|ddfqSrNrNr&rir)inforestr&r'rk&s rFcsg|] }|ddfqS)rNrNr&rF)rr&r'rk*s)r rnrrr)rrr&)rrrr'rs0     rTcCs t|}t|r |S|j|dS)a\ Converts expr to Algebraic Normal Form (ANF). ANF is a canonical normal form, which means that two equivalent formulas will convert to the same ANF. A logical expression is in ANF if it has the form .. math:: 1 \oplus a \oplus b \oplus ab \oplus abc i.e. it can be: - purely true, - purely false, - conjunction of variables, - exclusive disjunction. The exclusive disjunction can only contain true, variables or conjunction of variables. No negations are permitted. If ``deep`` is ``False``, arguments of the boolean expression are considered variables, i.e. only the top-level expression is converted to ANF. Examples ======== >>> from sympy.logic.boolalg import And, Or, Not, Implies, Equivalent >>> from sympy.logic.boolalg import to_anf >>> from sympy.abc import A, B, C >>> to_anf(Not(A)) A ^ True >>> to_anf(And(Or(A, B), Not(C))) A ^ B ^ (A & B) ^ (A & C) ^ (B & C) ^ (A & B & C) >>> to_anf(Implies(Not(A), Equivalent(B, C)), deep=False) True ^ ~A ^ (~A & (Equivalent(B, C))) r)ris_anfr)rUrr&r&r'r1s% rcCst||r|S||S)aS Converts ``expr`` to Negation Normal Form (NNF). A logical expression is in NNF if it contains only :py:class:`~.And`, :py:class:`~.Or` and :py:class:`~.Not`, and :py:class:`~.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)) )is_nnfrK)rUrJr&r&r'rK]s  rKFcCsjt|}t|ts |S|r%|stt|dkrttdt|dd|dSt|r+|St |}t |}|S)ao Convert a propositional logical sentence ``expr`` to conjunctive normal form: ``((A | ~B | ...) & (B | C | ...) & ...)``. If ``simplify`` is ``True``, ``expr`` is evaluated to its simplest CNF form using the Quine-McCluskey algorithm; this may take a long time. If there are more than 8 variables the ``force`` flag must be set to ``True`` to simplify (default is ``False``). 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  To simplify a logical expression with more than 8 variables may take a long time and requires the use of `force=True`.cnfTforce) rr rrQ_find_predicatesrrris_cnfeliminate_implicationsr)rUrJrresr&r&r'to_cnfvs  rcCsft|}t|ts |S|r%|stt|dkrttdt|dd|dSt|r+|St |}t |S)a Convert a propositional logical sentence ``expr`` to disjunctive normal form: ``((A & ~B & ...) | (B & C & ...) | ...)``. If ``simplify`` is ``True``, ``expr`` is evaluated to its simplest DNF form using the Quine-McCluskey algorithm; this may take a long time. If there are more than 8 variables, the ``force`` flag must be set to ``True`` to simplify (default is ``False``). 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 rrdnfTr) rr rrQrrrris_dnfrr)rUrJrr&r&r'to_dnfs  rcCst|}t|rt|tsdSt|tr"|jD]}|jsdSqdSt|trQ|jD]$}t|tr?|jD] }|js=dSq4q*t|rLt|trKdSq*dSdSdS)a Checks if ``expr`` is in Algebraic Normal Form (ANF). A logical expression is in ANF if it has the form .. math:: 1 \oplus a \oplus b \oplus ab \oplus abc i.e. it is purely true, purely false, conjunction of variables or exclusive disjunction. The exclusive disjunction can only contain true, variables or conjunction of variables. No negations are permitted. Examples ======== >>> from sympy.logic.boolalg import And, Not, Xor, true, is_anf >>> from sympy.abc import A, B, C >>> is_anf(true) True >>> is_anf(A) True >>> is_anf(And(A, B, C)) True >>> is_anf(Xor(A, Not(B))) False TF)rrr r5r-rnrfr<)rUrrr&r&r'rs0       rcCs|t|}t|r dS|g}|r<|}|jttfvr4|r-|j}|D] }t||vr,dSq!||jnt|s:dS|sdS)a Checks if ``expr`` is in Negation Normal Form (NNF). A logical expression is in NNF if it contains only :py:class:`~.And`, :py:class:`~.Or` and :py:class:`~.Not`, and :py:class:`~.Not` is applied only to literals. If ``simplified`` 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 TF) rrrRrZr-r2rnr5r)rU simplifiedstackrnrr&r&r'rs$  rcC t|ttS)a( 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 )_is_formr-r2rr&r&r'r1s rcCr)aM 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 )rr2r-rr&r&r'rEs rcCst|}t||r||n|g}|D]-}t||r7t||r$||n|g}|D] }t|dur5dSq)qt|dur@dSqdS)zE Test whether or not an expression is of the required form. FT)rr rr)rU function1 function2valslitvals2lr&r&r'r[s   rcCs t|ddS)a Change :py:class:`~.Implies` and :py:class:`~.Equivalent` into :py:class:`~.And`, :py:class:`~.Or`, and :py:class:`~.Not`. That is, return an expression that is equivalent to ``expr``, 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) Fr)rKrr&r&r'ros rcslddlmttrtjdSdvstsjr dStts4tfddjDr4dSdS)a{ 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 r)AppliedPredicaterJTc3s |] }tp |jVqdSr+)r rrrrUr&r'r7s zis_literal..F) rprr r5rrnrrallrr&rr'rs  rcs8tttdtdddfdd|DS)a  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 rNcSs"t|tr ||jd S||Sr)r r5rn)rrr&r&r' append_symbols z"to_int_repr..append_symbolcs&g|]}fddt|DqS)csh|]}|qSr&r&r(rrr&r' r z)to_int_repr...rrrr&r'rkszto_int_repr..)dictrrHrQ)clausesrr&rr' to_int_reprs  rcCstdtttt|dS)a@ 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 rN)intjoinrrry)termr&r&r'term_to_integersrccszdd|D}t|}t|tst|sdStdt|d}|D]}|tt||}|r7t ||fVq!|Vq!dS)a Return a generator of all possible configurations of the input variables, and the result of the boolean expression for those values. Parameters ========== expr : Boolean expression variables : list of variables input : bool (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.utilities.iterables import ibin >>> 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, ibin(i, len(vars)))), value)) [(y, 0), (x, 0)] -> True [(y, 0), (x, 1)] -> False [(y, 1), (x, 0)] -> True [(y, 1), (x, 1)] -> True cSrr&)rrivr&r&r'rkrztruth_table..Nrwrepeat) rr rrrrQrrrr)rU variablesinputtablervaluer&r&r' truth_tables4rcCs:d}t|D]\}}|||kr|dkr|}qdSq|S)zm Checks if a pair of minterms differs by only one bit. If yes, returns index, else returns `-1`. r)rZ)minterm1minterm2indexr]rjr&r&r' _check_pair#s rcfddt|D}t|S)zh Converts a term in the expansion of a function from binary to its variable form (for SOP). c4g|]\}}|dkr|dkr|nt|qS)rrNr4rinvalrr&r'rk9z'_convert_to_varsSOP..)rZr-)mintermrtempr&rr'rg4 rgcr)zh Converts a term in the expansion of a function from binary to its variable form (for POS). cr)rrr4rrr&r'rkCrz'_convert_to_varsPOS..)rZr2)maxtermrrr&rr'rm>rrmcs&fddt|D}|stSt|S)z Converts a term in the expansion of a function from binary to its variable form (for ANF). Parameters ========== term : list of 1's and 0's (complementation pattern) variables : list of variables cs g|] \}}|dkr|qS)rNr&)rirtrr&r'rkTrSz'_convert_to_varsANF..)rZrr-)rrrr&rr'_convert_to_varsANFHs rc$ddfddtdDDS)zu Returns a list of lists, with all possible combinations of n zeros and ones with an odd number of ones. cS g|] }t|ddkr|qSrsumrir$r&r&r'rkarSz)_get_odd_parity_terms..cg|]}t|qSr&rrhrr&r'rkar rNrHrr&rr'ri\$ricr)zv Returns a list of lists, with all possible combinations of n zeros and ones with an even number of ones. cSr)rNrrrr&r&r'rkirSz*_get_even_parity_terms..crr&rrhrr&r'rkir rNrrr&rr'rndrrnc s sgSg}ttt}tt}tD]\}}tdd|D}|||qtd}t|D]<}||D]5} ||dD],} t| | } | dkrod|| <|| <| dd} d| | <| |vro|| qCq;q5|rxt|}| fdd |D|S) z Reduces a set of minterms, if possible, to a simplified set of minterms with one less variable in the terms using QM method. css|] }|dkrdVqdS)rNNr&rirr&r&r'r7{rEz$_simplified_pairs..rrNrNrcsg|] }|dur|qSr+r&rhtermsr&r'rkrz%_simplified_pairs..) rrHrQrrZrrr_simplified_pairsr) rsimplified_termstodotermdictrronesrr"rjrDrnewtermr&rr'rls4    rcsj|sgSt|}tfddt|Ddgdg|}tD]/\}}t|D]&\}}tddt||DrSd||<|d7<||d7<q-q%d}|rd}t|D]R} || r| t|D]C} | | kr|| r|| || kr|  t fd dtDrd|| <d}t D]\}}|rd| |<|d8<qqnq`i} tD]rC| vr| nfd dt|D| <tD]ekrBrBkrB| vr| nfd dt|D| <tfd dt|DrBd<d}tD]\}}|r@|r@d|<||d8<q$qq|sd} d } tD]}|| kr^} |} qO| d kr| dkrtD]8\}}|| krt| | D]'\}}|r||rd||<d}||d8<|d8<q}qn|sZfddtDS)z After the truth table has been sufficiently simplified, use the prime implicant table method to recognize and eliminate redundant pairs, and return the essential arguments. csg|]}dgqS)rr&rir)nl1r&r'rkr z#_rem_redundancy..rcss$|] \}}|dkp ||kVqdS)rNr&)rirmtr&r&r'r7rGz"_rem_redundancy..rNTFc3s |] }||kVqdSr+r&r)rowrow2r&r'r7cg|]}|qSr&r&rh)coli dommatrixr&r'rkrcrr&r&rh)col2irr&r'rkrc3s |] }||kVqdSr+r&r)colcol2r&r'r7rrcsg|] }|r|qSr&r&rh)colcountl1r&r'rkr)rQrHrZrr)rrntermsrowcountprimeiprimetermiranythingchangedrowirow2icolcachemaxterms bestcolidxr`r&) rrrrrrrrrrr'_rem_redundancys           &      Grcsg}t|}|D]i}t|tr|t||qt|trQt|}|D]}||q%t dt|dD]}tt || ||fdd|Dq5qt|tt frnt||krft dj|d|t|qtd|S)Nrwrcsg|]}|qSr&r&rdr&r'rk rz%_input_to_binlist..zTEach term must contain {bits} bits as there are {bits} variables (or be an integer).)bitsz2A term list can only contain lists, ints or dicts.)rQr rrrrrkeysrYrrupdater[rformatr#) inputlistrbinlistr r nonspecvarskeyrr&r r'_input_to_binlists,      rNcCsX|stSttt|}t||}t|pg|}|D] }||vr%td|qt|||S)a 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 :py:class:`~.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) | (~w & ~x) 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) | (~w & ~x) 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) | (~w & ~y) | (x & z & ~w) See also ======== POSform References ========== .. [1] https://en.wikipedia.org/wiki/Quine-McCluskey_algorithm .. [2] https://en.wikipedia.org/wiki/Don%27t-care_term #%s in minterms is also in dontcares)rr[rrrr _sop_form)rminterms dontcaresr r&r&r'SOPform s<   rcs,t||}t||}tfdd|DS)Ncrr&)rgrFrr&r'rke r z_sop_form..)rrr2)rrrra essentialr&rr'rb s  rcs|stStttt|}t|pg}|D] }||vr%td|qg}tdtdD]}t|}||vrC||vrC| |q0t ||}t ||}t fdd|DS)a 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 :py:class:`~.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) See also ======== SOPform References ========== .. [1] https://en.wikipedia.org/wiki/Quine-McCluskey_algorithm .. [2] https://en.wikipedia.org/wiki/Don%27t-care_term rrwrcrr&)rmrFrr&r'rk r zPOSform..) rr[rrrrrrQrrrrr-)rrrr rrrarr&rr'POSformh s$<     rcst}t|}|d|krtd||ftttt|}g}ttd|dD]\}}||dkr:||q+t fdd|Ddd iS) a The ANFform function converts the list of truth values to Algebraic Normal Form (ANF). The variables must be given as the first argument. Return True, False, logical :py:class:`~.And` function (i.e., the "Zhegalkin monomial") or logical :py:class:`~.Xor` function (i.e., the "Zhegalkin polynomial"). When True and False are represented by 1 and 0, respectively, then :py:class:`~.And` is multiplication and :py:class:`~.Xor` is addition. Formally a "Zhegalkin monomial" is the product (logical And) of a finite set of distinct variables, including the empty set whose product is denoted 1 (True). A "Zhegalkin polynomial" is the sum (logical Xor) of a set of Zhegalkin monomials, with the empty set denoted by 0 (False). Parameters ========== variables : list of variables truthvalues : list of 1's and 0's (result column of truth table) Examples ======== >>> from sympy.logic.boolalg import ANFform >>> from sympy.abc import x, y >>> ANFform([x], [1, 0]) x ^ True >>> ANFform([x, y], [0, 1, 1, 1]) x ^ y ^ (x & y) References ========== .. [1] https://en.wikipedia.org/wiki/Zhegalkin_polynomial rNz8The number of truth values must be equal to 2^%d, got %drwrrNcrr&)rrFrr&r'rk r zANFform..rF) rQrr[rr anf_coeffsrZrrr<)r truthvaluesn_varsn_valuescoeffsrrjrr&rr'ANFform s *   r c Csdt|}t|d}t|d|krtdt|dd|D}t|D]0}g}td||dD]}||d|ttdd|d||d|dq6|}q(|d S) a Convert a list of truth values of some boolean expression to the list of coefficients of the polynomial mod 2 (exclusive disjunction) representing the boolean expression in ANF (i.e., the "Zhegalkin polynomial"). There are `2^n` possible Zhegalkin monomials in `n` variables, since each monomial is fully specified by the presence or absence of each variable. We can enumerate all the monomials. For example, boolean function with four variables ``(a, b, c, d)`` can contain up to `2^4 = 16` monomials. The 13-th monomial is the product ``a & b & d``, because 13 in binary is 1, 1, 0, 1. A given monomial's presence or absence in a polynomial corresponds to that monomial's coefficient being 1 or 0 respectively. Examples ======== >>> from sympy.logic.boolalg import anf_coeffs, bool_monomial, Xor >>> from sympy.abc import a, b, c >>> truthvalues = [0, 1, 1, 0, 0, 1, 0, 1] >>> coeffs = anf_coeffs(truthvalues) >>> coeffs [0, 1, 1, 0, 0, 0, 1, 0] >>> polynomial = Xor(*[ ... bool_monomial(k, [a, b, c]) ... for k, coeff in enumerate(coeffs) if coeff == 1 ... ]) >>> polynomial b ^ c ^ (a & b) z{:b}rNrNz9The number of truth values must be a power of two, got %dcSsg|]}|gqSr&r&rr&r&r'rk" r zanf_coeffs..cSs||ASr+r&)r]yr&r&r'r( zanf_coeffs..r)rrQrrHrrr)rr`rrrjtmprDr&r&r'r s$  &rcC0t|tr t|t|}ttt|}t||S)a Return the k-th minterm. Minterms are numbered by a binary encoding of the complementation pattern of the variables. This convention assigns the value 1 to the direct form and 0 to the complemented form. Parameters ========== k : int or list of 1's and 0's (complementation pattern) variables : list of variables Examples ======== >>> from sympy.logic.boolalg import bool_minterm >>> from sympy.abc import x, y, z >>> bool_minterm([1, 0, 1], [x, y, z]) x & z & ~y >>> bool_minterm(6, [x, y, z]) x & y & ~z References ========== .. [1] https://en.wikipedia.org/wiki/Canonical_normal_form#Indexing_minterms )r rrrQr[rrrgr"rr&r&r' bool_minterm.   r&cCr$)a Return the k-th maxterm. Each maxterm is assigned an index based on the opposite conventional binary encoding used for minterms. The maxterm convention assigns the value 0 to the direct form and 1 to the complemented form. Parameters ========== k : int or list of 1's and 0's (complementation pattern) variables : list of variables Examples ======== >>> from sympy.logic.boolalg import bool_maxterm >>> from sympy.abc import x, y, z >>> bool_maxterm([1, 0, 1], [x, y, z]) y | ~x | ~z >>> bool_maxterm(6, [x, y, z]) z | ~x | ~y References ========== .. [1] https://en.wikipedia.org/wiki/Canonical_normal_form#Indexing_maxterms )r rrrQr[rrrmr%r&r&r' bool_maxtermR r'r(cCr$)aR Return the k-th monomial. Monomials are numbered by a binary encoding of the presence and absences of the variables. This convention assigns the value 1 to the presence of variable and 0 to the absence of variable. Each boolean function can be uniquely represented by a Zhegalkin Polynomial (Algebraic Normal Form). The Zhegalkin Polynomial of the boolean function with `n` variables can contain up to `2^n` monomials. We can enumerate all the monomials. Each monomial is fully specified by the presence or absence of each variable. For example, boolean function with four variables ``(a, b, c, d)`` can contain up to `2^4 = 16` monomials. The 13-th monomial is the product ``a & b & d``, because 13 in binary is 1, 1, 0, 1. Parameters ========== k : int or list of 1's and 0's variables : list of variables Examples ======== >>> from sympy.logic.boolalg import bool_monomial >>> from sympy.abc import x, y, z >>> bool_monomial([1, 0, 1], [x, y, z]) x & z >>> bool_monomial(6, [x, y, z]) x & y )r rrrQr[rrrr%r&r&r' bool_monomialv s # r)cCs$t|ts|hStjtt|jS)zHelper to find logical predicates in BooleanFunctions. A logical predicate is defined here as anything within a BooleanFunction that is not a BooleanFunction itself. )r rrlrmrrrnrr&r&r'r s rcsv|dvrtdt|}|r/d}|dkrt|}n|dkr!t|}|r/tdd|jDr/|Sdd lm}|rS||}dd l m }t t ||} | tt|| }t|tsZ|Si} i} dd lm} ||}|d uryt|}||||r|} | jr| }| | |<|| | <| j}||vrt|| |<|||s{| | }|d ur| | }t|}|st|d kr| | S|d urt|}|||st|d krt|}d }tt|dddd\}}||}dd|D}t|||}|d urt|||fdd|D}ngt|dt|dk}|dks)|d ur2|r2t|| | St || | S)ak This function simplifies a boolean function to its simplified version in SOP or POS form. The return type is an :py:class:`~.Or` or :py:class:`~.And` object in SymPy. Parameters ========== expr : Boolean 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 : bool (default ``True``) Indicates whether to recursively simplify any non-boolean functions contained within the input. force : bool (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. dontcare : Boolean Optimize expression under the assumption that inputs where this expression is true are don't care. This is useful in e.g. Piecewise conditions, where later conditions do not need to consider inputs that are converted by previous conditions. For example, if a previous condition is ``And(A, B)``, the simplification of expr can be made with don't cares for ``And(A, B)``. Examples ======== >>> from sympy.logic import simplify_logic >>> from sympy.abc import x, y, z >>> b = (~x & ~y & ~z) | ( ~x & ~y & z) >>> simplify_logic(b) ~x & ~y >>> simplify_logic(x | y, dontcare=y) x References ========== .. [1] https://en.wikipedia.org/wiki/Don%27t-care_term )Nrrzform can be cnf or dnf onlyFrrcs|]}t|VqdSr+)rrr&r&r'r7 sz!simplify_logic..rr?r)DummyNrcSs|dvS)NrJr&rr&r&r'r r"z simplify_logic..TrcSsg|] }|dkr dndqS)TrNrr&rhr&r&r'rk! rz"simplify_logic..csg|]}|vr|qSr&r&r dctruthtabler&r'rk% rrNrN)!rrrrrrnrBr@rErrJr[rrrrr rrr+r rRrrr5rYrrQrr_get_truthtablerr)rUformrrdontcareform_okr@rrJr`replundor+varr nvar dcvariablesrr truthtablebigr&r,r'r s~6                 rcsD|fddfdd|gggD}|ggkr gS|S)zN Return a list of all combinations leading to a True result for ``expr``. csBrfdd|D}|fdd|D|S|S)Ncs8g|]}|dtur|dtidg|dgqSrw)rrrhrr&r'rk5 8z4_get_truthtable.._get_tt..cs8g|]}|dtur|dtidg|dgqSrw)rrrrhr9r&r'rk6 r:)rRr)inputstab)_get_tt _variablesr9r'r=2 s z _get_truthtable.._get_ttcs g|] }|dr|dqSrwr&)rir")constr&r'rk9 rSz#_get_truthtable..)copy)rrUr?rr&)r=r>r?r'r.. s  r.c CsL|j}ttt|dd|D}|jD]d}|jr$||dd7<q|jr5||jddd7<qt|jtdd|jDf}|jD]0}|jrc||dd7<||d|d7<qG|jrt||jdd d7<qGt d qt t}t t | D]\}}ttd d|d D|d<|t||q|S) a Assign a 5-item fingerprint to each symbol in the equation: [ # of times it appeared as a Symbol; # of times it appeared as a Not(symbol); # of times it appeared as a Symbol in an And or Or; # of times it appeared as a Not(Symbol) in an And or Or; a sorted tuple of tuples, (i, j, k), where i is the number of arguments in an And or Or with which it appeared as a Symbol, and j is the number of arguments that were Not(Symbol); k is the number of times that (i, j) was seen. ] Examples ======== >>> from sympy.logic.boolalg import _finger as finger >>> from sympy import And, Or, Not, Xor, to_cnf, symbols >>> 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, 0, 1),)): [x], (0, 0, 1, 0, ((2, 1, 1),)): [a, b], (0, 0, 1, 2, ((2, 0, 1),)): [y]} >>> dict(finger(x & ~y)) {(0, 1, 0, 0, ()): [y], (1, 0, 0, 0, ()): [x]} In the following, the (5, 2, 6) means that there were 6 Or functions in which a symbol appeared as itself amongst 5 arguments in which there were also 2 negated symbols, e.g. ``(a0 | a1 | a2 | ~a3 | ~a4)`` is counted once for a0, a1 and a2. >>> dict(finger(to_cnf(Xor(*symbols('a:5'))))) {(0, 0, 8, 8, ((5, 0, 1), (5, 2, 6), (5, 4, 1))): [a0, a1, a2, a3, a4]} The equation must not have more than one level of nesting: >>> dict(finger(And(Or(x, y), y))) {(0, 0, 1, 0, ((2, 0, 1),)): [x], (1, 0, 1, 0, ((2, 0, 1),)): [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. cSs g|] }dgdttgqS)r)rr)rifir&r&r'rkp rSz_finger..rrNcss|]}t|tVqdSr+)r r5)riair&r&r'r7w sz_finger..rNrrzunexpected level of nestingcSsg|] \}}||fqSr&r&)rirjrDr&r&r'rk s)rPrrrrnrfrKrQrrDrriteritemsr[sortedr) eqrr rorCinvr"rr&r&r'_finger@ s*/  "rJcCs2dd}t|}t|}|||}|r||fS|S)a 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}) cSs|j|jkrdSt|jt|jkrdS|jr||iSt|}t|}t|t|kr-dSi}|D]+}||vr<dSt||t||krKdSt||D] \}}|||||<qQq3|S)a:Return the mapping that equates variables between two simplified boolean expressions if possible. By "simplified" we mean that a function has been denested and is either an And (or an Or) whose arguments are either symbols (x), negated symbols (Not(x)), or Or (or an And) whose arguments are only symbols or negated symbols. For example, ``And(x, Not(y), Or(w, Not(z)))``. Basic.match is not robust enough (see issue 4835) so this is a workaround that is valid for simplified boolean expressions NF)rrQrnrfrJr rZ)rrf1f2 matchdictr"rjr]r&r&r'match s(  zbool_map..match)r)bool1bool2rNrrrr&r&r'bool_map s$) rQc sddlmm|dur|dur|}t|jfdddd\}}t|dkr(|St|d ddd\}}d d |D}|rLt|d krLt|||j|||}t|||j|||}|jfd d t |D||}|S)a Replace patterns of Relational Parameters ========== rv : Expr Boolean expression patterns : tuple Tuple of tuples, with (pattern to simplify, simplified pattern) with two terms. measure : function Simplification measure. dominatingvalue : Boolean or ``None`` The dominating value for the function of consideration. For example, for :py:class:`~.And` ``S.false`` is dominating. As soon as one expression is ``S.false`` in :py:class:`~.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 :py:class:`~.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``. threeterm_patterns : tuple, optional Tuple of tuples, with (pattern to simplify, simplified pattern) with three terms. rr@ _canonicalNcrr+rrr?r&r'r rz4_apply_patternbased_simplification..TrrNcSstdd|jD S)Ncss|]}|jduVqdS)FN)is_realrPr&r&r'r7 szG_apply_patternbased_simplification....)r9rPrr&r&r'r s cSr r&r rhr&r&r'rk r z6_apply_patternbased_simplification..rcsg|]}|qSr&r&rh)rSr&r'rk r) rBr@rSrrnrQ,_apply_patternbased_threeterm_simplificationrZ*_apply_patternbased_twoterm_simplificationr) rr#rdominatingvaluereplacementvaluerrr nonRealRelr&rRr'r s4'    rcsddlm}m}ddlmmmd}|rt|dkrd}fdd|D}tt |}fd d|D} g} t t | dD]n\\} } \} }|D]c\}}g}t | |D]\}}t ||}||}|rl|||fqU|r|D];\}}||}||kr|gSt|ts|||s|||j||}|dkr| || | g|ffqqqJq@| rt| d d dd } | dd }|\}}|t|D]}||=q|dus|t|kr|j|kr|jD]}||qn||d}|rt|dks|S)z- Apply pattern-based two-term simplification.rMinMaxr>Gt _InequalityTrNFc$g|]}t|fr|jn|qSr&r reversedr4)r>r^r&r'rk) $z>_apply_patternbased_twoterm_simplification..c&g|]}t|r |fn||jfqSr&rar4r_r&r'rk- &cS|dSrr&pairr&r&r'rM r"z<_apply_patternbased_twoterm_simplification..rreverserNN)(sympy.functions.elementary.miscellaneousr[r\rBr>r^r_rQrrrrZrr rNrrr rTrCrnrFsortrbr5rZ)rr#rZrWrXrr[r\changedrtmpresultsrjpirDpjpatternsimprp1p2oldexprtmpresnp costsaving replacementidxnewrelrrr&r]r'rV s^            9rVc sddlm}m}ddlmmmd}|rt|dkrd}fdd|D}tt |}g} fd d|D} t t | dD]u\\} } \} }\}}|D]g\}}g}t | ||D]\}}}t |||}||}|rt|||fq[|r|D]<\}}||}||kr|gSt|ts|||s|||j||}|dkr| || | |g|ffqyqOqB| rt| d d dd } | dd }|\}}|t|D]}||=q|dus|t|kr|j|kr|jD]}||qn||d}|rt|dks|S)z/ Apply pattern-based three-term simplification.rrZr=Ltr_TrFcr`r&rar4)r=rr&r'rkm rcz@_apply_patternbased_threeterm_simplification..crdr&rar4rer&r'rks rfcSrgrr&rhr&r&r'r r"z>_apply_patternbased_threeterm_simplification..rjrNN)rlr[r\rBr=rr_rQrrrrZrr rNrrr rTrCrnrFrmrbr5rZ) rr#rZrWrXrr[r\rnrprorjrqrDrrr"pkrsrtrrurvp3rwrxryrzr{r|r}rrr&r~r'rUb s^ $           9rUcCsFddlm}ddlm}m}m}m}m}m}ddl m }ddl m }m } |d} |d} |d} t|| | || | tft|| | || | tft|| | || | || | ft|| | || | || | ft|| | || | || | ft|| | || | || | ft|| | || | || | ft|| | || | t|| tj|| tjft|| | || | || | | | ft|| | || | t| | k|| | || | ft|| | || | || | | | ft|| | || | || || | ft|| | || | t| | k|| | || | ft|| | || | || || | ft|| | || | t|| | || | t| | ktt|| | || | ft|| | || | t|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t|| | || | tft|| | || | t| dk||| | tft|| | || | t| dk||| | tff} | S) z Two-term patterns for And.rWildrcrdr>r^r=rAbsrZrrr) sympy.corerrBrcrdr>r^r=r$sympy.functions.elementary.complexesrrlr[r\r rr-rrrT)rrcrdr>r^r=rrr[r\rrr _matchers_andr&r&r'r s@   0$0$$0$JJ6666,00!rcCs*ddlm}ddlm}m}m}|d}|d}|d}t|||||||||tft|||||||||tft|||||||||tft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ft|||||||||t||||||ff}|S)z Three-term patterns for And.rr)rcr>r^rrr) rrrBrcr>r^r rr-)rrcr>r^rrrrr&r&r'r s.    2222222222222rcCsddlm}ddlm}m}m}m}m}m}ddl m }ddl m }m } |d} |d} |d} t|| | || | tft|| | || | tft|| | || | || | ft|| | || | || | ft|| | || | || | ft|| | || | || | ft|| | || | || | ft|| | || | t|| | t|| | ft|| | || | t|| | || | tft|| | || | || || | ft|| | || | t| | k|| | || | ft|| | || | || || | ft|| | || | || | | | ft|| | || | t| | k|| | || | ft|| | || | || | | | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| | ktt|| | || | ft|| | || | t| dk||| | tft|| | || | t| dk||| | tff} | S) z Two-term patterns for Or.rrrrrZrrr)rrrBrcrdr>r^r=rrrrlr[r\r rrTr2)rrcrdr>r^r=rrr[r\rrr _matchers_orr&r&r'rB s@   ,,$0$$0$66666600$rBc Csxddlm}m}ddlm}ddlm}m}m}m }m }m }|d} |d} |d} t || | || | || | ft || | || | || | ft || | || | || | ft || | || | || | ft || | || | || | ft || | || | || | ft || | || | t || || | || || | ft || | || | t| | kt || | || | t || | || | ft || | || | t || || | || || | ft || | || | t || || | || || | ft || | || | t| | kt || | || | t || | || | ft || | || | t || || | || || | ff } | S)z Two-term patterns for Xor.rrZrrrrr)rlr[r\rrrBrcrdr>r^r=rr r-rT) r[r\rrcrdr>r^r=rrrr _matchers_xorr&r&r'rp8 sH      rpcCsddlm}ddlm}m}t|ts|S|||r|S|}|j}t |dkr*|S| }|d|fddj |dd\}}|sA|S|sEt Sg} |D]y\} } } } | t jurn| t jur\t}na||| dkri|| k}nT|| k}nO||| dk} ||| dk}| r|r| jr|| k}n3t| |k|| k}n)| rt| |k|| k}n|r| jr|| k}nt| |k|| k}n t| |k|| k}| |qIt| S) zKreturn a simplified version of univariate boolean expression, else ``expr``rrrbrNFrT) err_on_Eq)rrrBrcrdr rrErPrQrR _intervalsrrNegativeInfinityInfinityrrY is_infiniter-rr2)rUrrcrdrr\r]okrjrnrr_incl_aincl_br&r&r'rf sR            rcCs>t|ts tdt|trt|jtdd|jDSdS)a Return the total number of inputs for the logic gates realizing the Boolean expression. Returns ======= int Number of gate inputs Note ==== Not all Boolean functions count as gate here, only those that are considered to be standard gates. These are: :py:class:`~.And`, :py:class:`~.Or`, :py:class:`~.Xor`, :py:class:`~.Not`, and :py:class:`~.ITE` (multiplexer). :py:class:`~.Nand`, :py:class:`~.Nor`, and :py:class:`~.Xnor` will be evaluated to ``Not(And())`` etc. Examples ======== >>> from sympy.logic import And, Or, Nand, Not, gateinputcount >>> from sympy.abc import x, y, z >>> expr = And(x, y) >>> gateinputcount(expr) 2 >>> gateinputcount(Or(expr, z)) 4 Note that ``Nand`` is automatically evaluated to ``Not(And())`` so >>> gateinputcount(Nand(x, y, z)) 4 >>> gateinputcount(Not(And(x, y, z))) 4 Although this can be avoided by using ``evaluate=False`` >>> gateinputcount(Nand(x, y, z, evaluate=False)) 3 Also note that a comparison will count as a Boolean variable: >>> gateinputcount(And(x > z, y >= 2)) 2 As will a symbol: >>> gateinputcount(x) 0 zExpression must be Booleancsr*r+)gateinputcountrFr&r&r'r7 r8z!gateinputcount..r)r r"r# BooleanGatesrQrnrrr&r&r'r s 5 rrt)FFr+)NTFN)NN)trx collectionsr itertoolsrrrrsympy.core.addrsympy.core.basicrsympy.core.cacher sympy.core.containersr sympy.core.decoratorsr r sympy.core.functionr rsympy.core.kindrrsympy.core.numbersrsympy.core.operationsrsympy.core.singletonrrsympy.core.sortingrsympy.core.sympifyrrrsympy.utilities.iterablesrrsympy.utilities.miscrr(r"rrrrrrxrr-r2r5r<r;r,rvr9rFrTrrrrrr0rrrKrrrrrrrrrrrinteger_to_termrrrgrmrrirnrrrrrrr rr&r(r)rrr.rJrQrrVrUrrrBrprrrr&r&r&r's         ) 4tJ Y!jt "TTu  ,  *( 81" D  +f K Q>7$$) GW BDD 1 * 4 -4