
    \h0                        S r SSKJrJrJr  SSKJrJr  SSKJ	r	J
r
JrJrJrJr  SSKJr  SSKJrJrJrJr  SSKJrJrJrJrJrJr   " S S	5      r " S
 S5      r " S S5      rSS jrS r  " S S5      r! " S S5      r"g)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                   b   ^  \ rS rSrSrSU 4S jjr\S 5       rS rS r	S r
\
rS rS	 rS
rU =r$ )Literal   a?  
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                    > [        U[        5      (       a  UR                  S   nSnO,[        U[        [        [
        45      (       a  U(       a  U) $ U$ [        TU ]  U 5      nXl        X#l	        U$ )Nr   T)

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

		:	CH	:;;C? ;r   rV   N)r=   rK   rL   rM   rN   rY   r9   rO   r   r6   rH   rC   r>   rP   rQ   rJ   r*   r(   r   r   m   s@    1 + +
?' Hr*   r   Nc                 
   SSK Jn  Uc  0 n[        UR                  [        UR
                  [        UR                  [        UR                  [        UR                  [        UR                  0n[        U 5      U;   a  U[        U 5         nU" U R                  6 n [!        U ["        5      (       a  U R                  S   n[%        XQ5      nU) $ [!        U [&        5      (       a6  [)        [&        R*                  " U 5       Vs/ s H  n[%        Xq5      PM     sn6 $ [!        U [,        5      (       a6  [/        [,        R*                  " U 5       Vs/ s H  n[%        Xq5      PM     sn6 $ [!        U [0        5      (       a/  [/        U R                   Vs/ s H  n[%        Xq5      PM     sn6 nU) $ [!        U [2        5      (       a/  [)        U R                   Vs/ s H  n[%        Xq5      PM     sn6 nU) $ [!        U [4        5      (       a  / n[7        S[9        U R                  5      S-   S5       Hm  n	[;        U R                  U	5       HP  n
U R                   Vs/ s H  nX;   a  [%        X5      ) O
[%        X5      PM!     nnUR=                  [)        U6 5        MR     Mo     [/        U6 $ [!        U [>        5      (       a  / n[7        S[9        U R                  5      S-   S5       Hm  n	[;        U R                  U	5       HP  n
U R                   Vs/ s H  nX;   a  [%        X5      ) O
[%        X5      PM!     nnUR=                  [)        U6 5        MR     Mo     [/        U6 ) $ [!        U [@        5      (       a>  [%        U R                  S   U5      [%        U R                  S   U5      p[)        U) U5      $ [!        U [B        5      (       av  / n[E        U R                  U R                  SS U R                  S   S9 H9  u  nn[%        X5      n[%        UU5      nUR=                  [)        U) U5      5        M;     [/        U6 $ [!        U [F        5      (       ak  [%        U R                  S   U5      n[%        U R                  S   U5      n[%        U R                  S   U5      n[/        [)        U) U5      [)        X5      5      $ [!        U [H        5      (       aF  U RJ                  U RL                  nnURO                  US5      nUb  [%        URP                  " U6 U5      $ [!        U [R        5      (       a!  URO                  U S5      nUb  [%        UU5      $ [U        U 5      $ s  snf s  snf s  snf s  snf s  snf s  snf )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))
r   )QN      )	fillvalue)+sympy.assumptions.askr   r   eqr	   ner
   gtr   ltr   ger   ler4   r   r   r   to_NNFr   r    	make_argsr   r   r   r   r   rangelenr   appendr   r   r   r   r   r   function	argumentsgetr6   r   r   )r5   composite_mapr   binrelpredspredr/   tmpxcnfsinegr~   clauseLRabMr   newpreds                       r(   r   r      sw   : ( 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$
##		499QR=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$   >U	U
UU&U&U$c                    [        U [        [        45      (       d0  [        5       nUR	                  [        U 45      5        [        U5      $ [        U [        5      (       a7  [        R                  " U R                   Vs/ s H  n[        U5      PM     sn6 $ [        U [        5      (       a7  [        R                  " U R                   Vs/ s H  n[        U5      PM     sn6 $ gs  snf s  snf )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)r5   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                       \ rS rSrSrSS jrS rS rS rS r	S	 r
\S
 5       rS rS rS rS rS rS r\S 5       r\S 5       r\S 5       r\S 5       rSrg)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                 2    U(       d
  [        5       nXl        g r,   )r   clausesr.   r   s     r(   rY   CNF.__init__   s    eGr*   c                 d    [         R                  U5      R                  nU R                  U5        g r,   )r   to_CNFr   add_clauses)r.   propr   s      r(   r   CNF.add%  s$    **T"**!r*   c                     SR                  U R                   VVs/ s H4  nSSR                  U Vs/ s H  n[        U5      PM     sn5      -   S-   PM6     snn5      nU$ s  snf s  snnf )Nr   rx   ry   rz   )r|   r   ra   )r.   r   r#   r~   s       r(   r>   CNF.__str__)  sf    JJ,,(& 5::6:6Cs3x6:;;S@&(
  ; (s   A%
A A%
 A%
c                 :    U H  nU R                  U5        M     U $ r,   r   )r.   propsps      r(   extend
CNF.extend0  s    AHHQK r*   c                 >    [        [        U R                  5      5      $ r,   )r   r   r   r-   s    r(   copyCNF.copy5  s    3t||$%%r*   c                 .    U =R                   U-  sl         g r,   r   r   s     r(   r   CNF.add_clauses8  s    r*   c                 6    U " 5       nUR                  U5        U$ r,   r   )r%   r   ress      r(   	from_propCNF.from_prop;  s    e
r*   c                 <    U R                  UR                  5        U $ r,   )r   r   rA   s     r(   __iand__CNF.__iand__A  s    'r*   c                     [        5       nU R                   H!  nX Vs1 s H  o3R                  iM     sn-  nM#     U$ s  snf r,   )r   r   r#   )r.   
predicatescr/   s       r(   all_predicatesCNF.all_predicatesE  s=    U
Aa0as77a00J  1s   >c                     [        5       n[        U R                  UR                  5       H;  u  p4[        U5      nUR                  U5        UR	                  [        U5      5        M=     [        U5      $ 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    U R                   R                  UR                   5      n[        U5      $ r,   )r   unionr   )r.   r   r   s      r(   _andCNF._andS  s$    ,,$$S[[17|r*   c                     [        U R                  5      nUS    Vs1 s H  n[        U) 45      iM     nn[        U5      nUS S  H:  nU Vs1 s H  n[        U) 45      iM     nnUR	                  [        U5      5      nM<     U$ s  snf s  snf )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                     / nU R                    H:  nU Vs/ s H  oDR                  U5      PM     nnUR                  [        U6 5        M<     [	        U6 n[        U5      $ s  snf r,   )r   r6   r   r    r   r   )r.   r5   clause_listr   r/   litss         r(   r6   	CNF.rcalla  s]    llF/56vIIdOvD6r4y) # K %d++ 7s   A c                 f    US   R                  5       nUSS   H  nUR                  U5      nM     U$ Nr   r   )r   r   r%   r   r   r   s       r(   r   
CNF.all_ori  s3    GLLNHDdA r*   c                 f    US   R                  5       nUSS   H  nUR                  U5      nM     U$ r   )r   r   r   s       r(   r   CNF.all_andp  s3    GLLNHDtA r*   c                 H    SSK Jn  [        X" 5       5      n[        U5      nU$ )Nr   )get_composite_predicates)sympy.assumptions.factsr   r   r   )r%   r5   r   s      r(   r   
CNF.to_CNFw  s$    Dd467%d+r*   c                 B   ^ S m[        U4S jUR                   5       6 $ )zU
Converts CNF object to SymPy's boolean expression
retaining the form of expression.
c                 f    U R                   (       a  [        U R                  5      $ U R                  $ r,   )r$   r   r#   )r/   s    r(   remove_literal&CNF.CNF_to_cnf.<locals>.remove_literal  s    #&::3sww<:377:r*   c              3   H   >#    U  H  n[        U4S  jU 5       6 v   M     g7f)c              3   4   >#    U  H  nT" U5      v   M     g 7fr,   rJ   ).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=   rK   rL   rM   rN   rY   r   r>   r   r   r   classmethodr   r   r   r   r   r   r6   r   r   r   r
  rQ   rJ   r*   r(   r   r     s    "
"
&   
,       ^ ^r*   r   c                   f    \ rS rSrSrSS jrS r\S 5       r\S 5       r	S r
S	 rS
 rS rS rSrg)
EncodedCNFi  z(
Class for encoding the CNF expression.
Nc                 |    U(       d  U(       d  / n0 nXl         X l        [        UR                  5       5      U l        g r,   )dataencodingr   keys_symbols)r.   r  r  s      r(   rY   EncodedCNF.__init__  s-    HDH	 X]]_-r*   c           
      6   [        UR                  5       5      U l        [        U R                  5      n[	        [        U R                  [        SUS-   5      5      5      U l        UR                   Vs/ s H  o0R                  U5      PM     snU l
        g s  snf Nr   )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   3Bc                     U R                   $ r,   )r  r-   s    r(   symbolsEncodedCNF.symbols  s    }}r*   c                 F    [        S[        U R                  5      S-   5      $ r  )r   r   r  r-   s    r(   	variablesEncodedCNF.variables  s    QDMM*Q.//r*   c                     U R                    Vs/ s H  n[        U5      PM     nn[        U[        U R                  5      5      $ s  snf 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                 P    [         R                  U5      nU R                  U5        g r,   )r   r   add_from_cnf)r.   r   r   s      r(   add_propEncodedCNF.add_prop  s    mmD!#r*   c                     UR                    Vs/ s H  o R                  U5      PM     nnU =R                  U-  sl        g s  snf 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                 
   UR                   nU R                  R                  US 5      nUcC  [        U R                  5      nU R                  R                  U5        US-   =o0R                  U'   UR                  (       a  U* $ U$ r  )r#   r  r   r   r  r   r$   )r.   r/   literalvaluer  s        r(   
encode_argEncodedCNF.encode_arg  sn    ''!!'40=DMM"AMM  )-.U2EMM'*::6MLr*   c                     U Vs1 s H3  o"R                   [        R                  :X  d  U R                  U5      OSiM5     sn$ s  snf )Nr   )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=   rK   rL   rM   rN   rY   r  rO   r  r!  r   r(  r'  r/  r  rQ   rJ   r*   r(   r  r    sT    .D   0 09
Yr*   r  r,   )#rN   	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  rJ   r*   r(   <module>r9     sr    9 8 @ 8 8 " 2 2 J J; ;| @ @jZ5(y^ y^x3Y 3Yr*   