+
    i0                        R t ^ RIHtHtHt ^ RIHtHt ^ RIH	t	H
t
HtHtHtHt ^ RIHt ^ RIHtHtHtHt ^ RIHtHtHtHtHtHt  ! R R4      t ! R	 R
4      t ! R R4      tRR ltR t  ! R R4      t! ! R R4      t"R# )a  
The classes used here are for the internal use of assumptions system
only and should not be used anywhere else as these do not possess the
signatures common to SymPy objects. For general use of logic constructs
please refer to sympy.logic classes And, Or, Not, etc.
)combinationsproductzip_longest)AppliedPredicate	Predicate)EqNeGtLtGeLe)S)OrAndNotXnor)
EquivalentITEImpliesNandNorXorc                   l   a a ] tR t^t oRtR
V 3R llt]R 4       tR tR t	R t
]
tR tR tR	tVtV ;t# )Literala?  
The smallest element of a CNF object.

Parameters
==========

lit : Boolean expression

is_Not : bool

Examples
========

>>> from sympy import Q
>>> from sympy.assumptions.cnf import Literal
>>> from sympy.abc import x
>>> Literal(Q.even(x))
Literal(Q.even(x), False)
>>> Literal(~Q.even(x))
Literal(Q.even(x), True)
c                   < \        V\        4      '       d   VP                  ^ ,          pRpM.\        V\        \        \
        34      '       d   V'       d   V( # T# \        SV `  V 4      pWn        W#n	        V# )    T)

isinstancer   argsANDORr   super__new__litis_Not)clsr"   r#   obj	__class__s   &&& S/var/www/html/photoedit/myenv/lib/python3.14/site-packages/sympy/assumptions/cnf.pyr!   Literal.__new__&   sb    c3((1+CFc2w/00!C4*s*goc"

    c                    V P                   # N)r"   selfs   &r'   argLiteral.arg1   s    xxr)   c                    \        V P                  4      '       d   V P                  V4      pMV P                  P                  V4      p\        V 4      ! W P                  4      # r+   )callabler"   applytyper#   )r-   exprr"   s   && r'   rcallLiteral.rcall5   sC    DHH((4.C((..&CDz#{{++r)   c                P    V P                   '       * p\        V P                  V4      # r+   )r#   r   r"   )r-   r#   s   & r'   
__invert__Literal.__invert__<   s    [[txx((r)   c                v    R P                  \        V 4      P                  V P                  V P                  4      # )z
{}({}, {}))formatr3   __name__r"   r#   r,   s   &r'   __str__Literal.__str__@   s)    ""4:#6#6$++NNr)   c                v    V P                   VP                   8H  ;'       d    V P                  VP                  8H  # r+   )r.   r#   r-   others   &&r'   __eq__Literal.__eq__E   s*    xx599$DD)DDr)   c                p    \        \        V 4      P                  V P                  V P                  34      pV# r+   )hashr3   r<   r.   r#   )r-   hs   & r'   __hash__Literal.__hash__H   s*    $t*%%txx=>r)    )F)r<   
__module____qualname____firstlineno____doc__r!   propertyr.   r5   r8   r=   __repr__rB   rG   __static_attributes____classdictcell____classcell__)r&   __classdict__s   @@r'   r   r      sJ     ,	  ,)O HE r)   r   c                   \   a  ] tR t^Mt o RtR t]R 4       tR tR t	R t
R tR t]tR	tV tR
# )r   z#
A low-level implementation for Or
c                    Wn         R # r+   _argsr-   r   s   &*r'   __init__OR.__init__Q       
r)   c                8    \        V P                  \        R 7      # )keysortedrW   strr,   s   &r'   r   OR.argsT       djjc**r)   c                |    \        V 4      ! V P                   Uu. uF  pVP                  V4      NK  	  up!  # u upi r+   r3   rW   r5   r-   r4   r.   s   && r'   r5   OR.rcallX   ?    Dz'+zz'1  IIdO'1  	    9c                R    \        V P                   Uu. uF  q( NK  	  up!  # u upi r+   )r   rW   r-   r.   s   & r'   r8   OR.__invert__]   s#    TZZ0ZcTZ0110   $c                t    \        \        V 4      P                  3\        V P                  4      ,           4      # r+   rE   r3   r<   tupler   r,   s   &r'   rG   OR.__hash__`   (    T$Z((*U499-==>>r)   c                4    V P                   VP                   8H  # r+   r   r@   s   &&r'   rB   	OR.__eq__c       yyEJJ&&r)   c           	         R RP                  V P                   Uu. uF  p\        V4      NK  	  up4      ,           R,           pV# u upi )( | )joinr   ra   r-   r.   ss   &  r'   r=   
OR.__str__f   s;    %**$))<)3c#h)<==C =   A
rV   N)r<   rJ   rK   rL   rM   rY   rN   r   r5   r8   rG   rB   r=   rO   rP   rQ   rS   s   @r'   r   r   M   sC      + +
2?' Hr)   r   c                   \   a  ] tR t^mt o RtR tR t]R 4       tR t	R t
R tR t]tR	tV tR
# )r   z$
A low-level implementation for And
c                    Wn         R # r+   rV   rX   s   &*r'   rY   AND.__init__q   r[   r)   c                R    \        V P                   Uu. uF  q( NK  	  up!  # u upi r+   )r   rW   rk   s   & r'   r8   AND.__invert__t   s#    DJJ/JSDJ/00/rm   c                8    \        V P                  \        R 7      # r]   r_   r,   s   &r'   r   AND.argsw   rc   r)   c                |    \        V 4      ! V P                   Uu. uF  pVP                  V4      NK  	  up!  # u upi r+   re   rf   s   && r'   r5   	AND.rcall{   rh   ri   c                t    \        \        V 4      P                  3\        V P                  4      ,           4      # r+   ro   r,   s   &r'   rG   AND.__hash__   rr   r)   c                4    V P                   VP                   8H  # r+   rt   r@   s   &&r'   rB   
AND.__eq__   rv   r)   c           	         R RP                  V P                   Uu. uF  p\        V4      NK  	  up4      ,           R,           pV# u upi )rx    & rz   r{   r}   s   &  r'   r=   AND.__str__   s;    

		:	CH	:;;C? ;r   rV   N)r<   rJ   rK   rL   rM   rY   r8   rN   r   r5   rG   rB   r=   rO   rP   rQ   r   s   @r'   r   r   m   sC     1 + +
?' Hr)   r   Nc                ^   ^ RI Hp Vf   / p\        VP                  \        VP
                  \        VP                  \        VP                  \        VP                  \        VP                  /p\        V 4      V9   d#   V\        V 4      ,          pV! V P                  !  p \!        V \"        4      '       d"   V P                  ^ ,          p\%        WQ4      pV( # \!        V \&        4      '       d7   \)        \&        P*                  ! V 4       Uu. uF  p\%        Wq4      NK  	  up!  # \!        V \,        4      '       d7   \/        \,        P*                  ! V 4       Uu. uF  p\%        Wq4      NK  	  up!  # \!        V \0        4      '       d0   \/        V P                   Uu. uF  p\%        Wq4      NK  	  up!  pV( # \!        V \2        4      '       d0   \)        V P                   Uu. uF  p\%        Wq4      NK  	  up!  pV( # \!        V \4        4      '       d   . p\7        ^ \9        V P                  4      ^,           ^4       Fn  p	\;        V P                  V	4       FQ  p
V P                   Uu. uF   pW9   d   \%        W4      ( M
\%        W4      NK"  	  ppVP=                  \)        V!  4       KS  	  Kp  	  \/        V!  # \!        V \>        4      '       d   . p\7        ^ \9        V P                  4      ^,           ^4       Fn  p	\;        V P                  V	4       FQ  p
V P                   Uu. uF   pW9   d   \%        W4      ( M
\%        W4      NK"  	  ppVP=                  \)        V!  4       KS  	  Kp  	  \/        V!  ( # \!        V \@        4      '       dG   \%        V P                  ^ ,          V4      \%        V P                  ^,          V4      r\)        V( V4      # \!        V \B        4      '       d   . p\E        V P                  V P                  R,          V P                  ^ ,          R7       F9  w  pp\%        W4      p\%        VV4      pVP=                  \)        V( V4      4       K;  	  \/        V!  # \!        V \F        4      '       dx   \%        V P                  ^ ,          V4      p\%        V P                  ^,          V4      p\%        V P                  ^,          V4      p\/        \)        V( V4      \)        W4      4      # \!        V \H        4      '       dI   V PJ                  V PL                  ppVPO                  VR4      pVe   \%        VPP                  ! V!  V4      # \!        V \R        4      '       d#   VPO                  V R4      pVe   \%        VV4      # \U        V 4      # u upi u upi u upi u upi u upi u upi )a6  
Generates the Negation Normal Form of any boolean expression in terms
of AND, OR, and Literal objects.

Examples
========

>>> from sympy import Q, Eq
>>> from sympy.assumptions.cnf import to_NNF
>>> from sympy.abc import x, y
>>> expr = Q.even(x) & ~Q.positive(x)
>>> to_NNF(expr)
(Literal(Q.even(x), False) & Literal(Q.positive(x), True))

Supported boolean objects are converted to corresponding predicates.

>>> to_NNF(Eq(x, y))
Literal(Q.eq(x, y), False)

If ``composite_map`` argument is given, ``to_NNF`` decomposes the
specified predicate into a combination of primitive predicates.

>>> cmap = {Q.nonpositive: Q.negative | Q.zero}
>>> to_NNF(Q.nonpositive, cmap)
(Literal(Q.negative, False) | Literal(Q.zero, False))
>>> to_NNF(Q.nonpositive(x), cmap)
(Literal(Q.negative(x), False) | Literal(Q.zero(x), False))
)QN   NN)	fillvalue)+sympy.assumptions.askr   r   eqr   ner	   gtr
   ltr   ger   ler3   r   r   r   to_NNFr   r   	make_argsr   r   r   r   r   rangelenr   appendr   r   r   r   r   r   function	argumentsgetr5   r   r   )r4   composite_mapr   binrelpredspredr.   tmpxcnfsinegr~   clauseLRabMr   newpreds   &&                  r'   r   r      su   : ( qttRr144QTT2qttRNKDz[ 4:&TYY$iilS(t$bll46HI6HF1,6HIJJ$s}}T7JK7J!VA-7JKLL$dii@iF1,i@At$TYY?Y6!+Y?@t$q#dii.1,a0A#DIIq1#'99.#,a 89x6!33VAE]]#,  .BK( 2 1
 Dz$q#dii.1,a0A#DIIq1#'99.#,a 89x6!33VAE]]#,  .BK( 2 1
 T
{$  diilM2F499Q<4W11"ay$
##		499R=DIIaLQDAqq(Aq-(AKKA2q	" R Dz$499Q</499Q</499Q</2qb!9bh''$())]]DNNd##D$/'--.>>$	""##D$/'=114=y J L A @..s$   VVVV #&V%&V*c                   \        V \        \        34      '       g1   \        4       pVP	                  \        V 34      4       \        V4      # \        V \        4      '       d8   \        P                  ! V P                   Uu. uF  p\        V4      NK  	  up!  # \        V \        4      '       d8   \        P                  ! V P                   Uu. uF  p\        V4      NK  	  up!  # R# u upi u upi )z|
Distributes AND over OR in the NNF expression.
Returns the result( Conjunctive Normal Form of expression)
as a CNF object.
N)r   r   r   setadd	frozensetCNFall_orrW   distribute_AND_over_ORall_and)r4   r   r.   s   &  r'   r   r      s     dS"I&&e	4'"#3x$zz'+zz3'1 337'13 4 	4 ${{(,

4(2 4C8(24 5 	5 34s   C)C.c                      a  ] tR tRt o RtRR ltR tR tR tR t	R	 t
]R
 4       tR tR tR tR tR tR t]R 4       t]R 4       t]R 4       t]R 4       tRtV tR# )r   i  a  
Class to represent CNF of a Boolean expression.
Consists of set of clauses, which themselves are stored as
frozenset of Literal objects.

Examples
========

>>> from sympy import Q
>>> from sympy.assumptions.cnf import CNF
>>> from sympy.abc import x
>>> cnf = CNF.from_prop(Q.real(x) & ~Q.zero(x))
>>> cnf.clauses
{frozenset({Literal(Q.zero(x), True)}),
frozenset({Literal(Q.negative(x), False),
Literal(Q.positive(x), False), Literal(Q.zero(x), False)})}
Nc                6    V'       g   \        4       pWn        R # r+   )r   clausesr-   r   s   &&r'   rY   CNF.__init__   s    eGr)   c                f    \         P                  V4      P                  pV P                  V4       R # r+   )r   to_CNFr   add_clauses)r-   propr   s   && r'   r   CNF.add%  s$    **T"**!r)   c                    R P                  V P                   UUu. uF;  pRRP                  V Uu. uF  p\        V4      NK  	  up4      ,           R,           NK=  	  upp4      pV# u upi u uppi )r   rx   ry   rz   )r|   r   ra   )r-   r   r"   r~   s   &   r'   r=   CNF.__str__)  si    JJ,,(& 5::6:6Cs3x6:;;S@@&(
  ; (s   A+
A&A+
&A+
c                :    V F  pV P                  V4       K  	  V # r+   r   )r-   propsps   && r'   extend
CNF.extend0  s    AHHQK r)   c                >    \        \        V P                  4      4      # r+   )r   r   r   r,   s   &r'   copyCNF.copy5  s    3t||$%%r)   c                8    V ;P                   V,          un         R # r+   r   r   s   &&r'   r   CNF.add_clauses8  s    r)   c                6    V ! 4       pVP                  V4       V# r+   r   )r$   r   ress   && r'   	from_propCNF.from_prop;  s    e
r)   c                <    V P                  VP                  4       V # r+   )r   r   r@   s   &&r'   __iand__CNF.__iand__A  s    'r)   c                    \        4       pV P                   F$  pY Uu0 uF  q3P                  kK  	  up,          pK&  	  V# u upi r+   )r   r   r"   )r-   
predicatescr.   s   &   r'   all_predicatesCNF.all_predicatesE  s=    U
Aa0as77a00J  1s   Ac                    \        4       p\        V P                  VP                  4       F;  w  r4\        V4      pVP                  V4       VP	                  \        V4      4       K=  	  \        V4      # r+   )r   r   r   updater   r   r   )r-   cnfr   r   r   r   s   &&    r'   _orCNF._orK  sT    %DLL#++6DAa&CJJqMKK	#' 7 7|r)   c                b    V P                   P                  VP                   4      p\        V4      # r+   )r   unionr   )r-   r   r   s   && r'   _andCNF._andS  s$    ,,$$S[[17|r)   c                $   \        V P                  4      pVR,           Uu0 uF  p\        V( 34      kK  	  pp\        V4      pVRR  F9  pV Uu0 uF  p\        V( 34      kK  	  ppVP	                  \        V4      4      pK;  	  V# u upi u upi )r   N)listr   r   r   r   )r-   clssr   llrestr   s   &     r'   _notCNF._notW  s    DLL!(,R11i!1W"ID+/04aQB5!4A0AB  	 2 1s   BBc                    . pV P                    F:  pV Uu. uF  qDP                  V4      NK  	  ppVP                  \        V!  4       K<  	  \	        V!  p\        V4      # u upi r+   )r   r5   r   r   r   r   )r-   r4   clause_listr   r.   litss   &&    r'   r5   	CNF.rcalla  s]    llF/56vIIdOvD6r4y) # K %d++ 7s   A!c                v    V^ ,          P                  4       pVR,           F  pVP                  V4      pK  	  V# r   r   )r   r   r$   r   r   r   s   &*  r'   r   
CNF.all_ori  s3    GLLNHHDdA r)   c                v    V^ ,          P                  4       pVR,           F  pVP                  V4      pK  	  V# r   )r   r   r   s   &*  r'   r   CNF.all_andp  s3    GLLNHHDtA r)   c                H    ^ RI Hp \        W! 4       4      p\        V4      pV# )r   )get_composite_predicates)sympy.assumptions.factsr   r   r   )r$   r4   r   s   && r'   r   
CNF.to_CNFw  s$    Dd467%d+r)   c                D   a R o\        V3R lVP                   4       !  # )zU
Converts CNF object to SymPy's boolean expression
retaining the form of expression.
c                 h    V P                   '       d   \        V P                  4      # V P                  # r+   )r#   r   r"   )r.   s   &r'   remove_literal&CNF.CNF_to_cnf.<locals>.remove_literal  s!    #&:::3sww<:377:r)   c              3   J   <"   T F  p\        V3R  lV 4       !  x  K  	  R# 5i)c              3   4   <"   T F  pS! V4      x  K  	  R # 5ir+   rI   ).0r.   r  s   & r'   	<genexpr>+CNF.CNF_to_cnf.<locals>.<genexpr>.<genexpr>  s     @#.--s   N)r   )r  r   r  s   & r'   r  !CNF.CNF_to_cnf.<locals>.<genexpr>  s     \P[fR@@AP[s    #)r   r   )r$   r   r  s   &&@r'   
CNF_to_cnfCNF.CNF_to_cnf~  s"    	; \PSP[P[\]]r)   r   r+   )r<   rJ   rK   rL   rM   rY   r   r=   r   r   r   classmethodr   r   r   r   r   r   r5   r   r   r   r
  rP   rQ   r   s   @r'   r   r     s     "
"
&   
,       ^ ^r)   r   c                   r   a  ] tR tRt o RtRR ltR t]R 4       t]R 4       t	R t
R	 tR
 tR tR tRtV tR# )
EncodedCNFi  z(
Class for encoding the CNF expression.
Nc                    V'       g   V'       g   . p/ pWn         W n        \        VP                  4       4      V n        R # r+   )dataencodingr   keys_symbols)r-   r  r  s   &&&r'   rY   EncodedCNF.__init__  s-    HDH	 X]]_-r)   c           
     >   \        VP                  4       4      V n        \        V P                  4      p\	        \        V P                  \        ^V^,           4      4      4      V n        VP                   Uu. uF  q0P                  V4      NK  	  upV n
        R# u upi )r   N)r   r   r  r   dictzipr   r  r   encoder  )r-   r   nr   s   &&  r'   from_cnfEncodedCNF.from_cnf  sj    S//12SaQ@A7:{{C{V[[({C	Cs   7Bc                    V P                   # r+   )r  r,   s   &r'   symbolsEncodedCNF.symbols  s    }}r)   c                N    \        ^\        V P                  4      ^,           4      # )r   )r   r   r  r,   s   &r'   	variablesEncodedCNF.variables  s    QDMM*Q.//r)   c                    V P                    Uu. uF  p\        V4      NK  	  pp\        V\        V P                  4      4      # u upi r+   )r  r   r  r  r  )r-   r   new_datas   &  r'   r   EncodedCNF.copy  s9    .2ii8iFCKi8(D$788 9s   Ac                R    \         P                  V4      pV P                  V4       R # r+   )r   r   add_from_cnf)r-   r   r   s   && r'   add_propEncodedCNF.add_prop  s    mmD!#r)   c                    VP                    Uu. uF  q P                  V4      NK  	  ppV ;P                  V,          un        R # u upi r+   )r   r  r  )r-   r   r   r   s   &&  r'   r&  EncodedCNF.add_from_cnf  s5    58[[A[6;;v&[A		W	 Bs   Ac                   VP                   pV P                  P                  VR 4      pVfH   \        V P                  4      pV P                  P                  V4       V^,           ;q0P                  V&   VP                  '       d   V) # V# r+   )r"   r  r   r   r  r   r#   )r-   r.   literalvaluer  s   &&   r'   
encode_argEncodedCNF.encode_arg  sp    ''!!'40=DMM"AMM  )-.U2EMM'*:::6MLr)   c                    V Uu0 uF4  q"P                   \        P                  8X  g   V P                  V4      M^ kK6  	  up# u upi )r   )r"   r   falser.  )r-   r   r.   s   && r'   r  EncodedCNF.encode  s7    QWXQW#GGqww,>$AEQWXXXs   :A)r  r  r  )NN)r<   rJ   rK   rL   rM   rY   r  rN   r  r   r   r'  r&  r.  r  rP   rQ   r   s   @r'   r  r    s]     .D   0 09
Y Yr)   r  r+   )#rM   	itertoolsr   r   r   sympy.assumptions.assumer   r   sympy.core.relationalr   r   r	   r
   r   r   sympy.core.singletonr   sympy.logic.boolalgr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  rI   r)   r'   <module>r8     sr    9 8 @ 8 8 " 2 2 J J; ;| @ @jZ5(y^ y^x3Y 3Yr)   