
    wg0                        d Z ddlmZmZmZ ddlmZmZ ddlm	Z	m
Z
mZmZmZmZ ddlmZ ddlmZmZmZmZ ddlmZmZmZmZmZmZ  G d d	      Z G d
 d      Z G d d      ZddZd Z  G d d      Z! G d d      Z"y)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                   V     e Zd ZdZd	 fd	Zed        Zd Zd Zd Z	e	Z
d Zd Z xZS )
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                     t        |t              r|j                  d   }d}n"t        |t        t        t
        f      r|r| S |S t        |   |       }||_        ||_	        |S )Nr   T)

isinstancer   argsANDORr   super__new__litis_Not)clsr"   r#   obj	__class__s       Z/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/assumptions/cnf.pyr!   zLiteral.__new__&   s`    c3((1+CFc2w/0!C4*s*goc"

    c                     | j                   S N)r"   selfs    r'   argzLiteral.arg1   s    xxr(   c                     t        | j                        r| j                  |      }n| j                  j                  |      } t        |       || j                        S r*   )callabler"   applytyper#   )r,   exprr"   s      r'   rcallzLiteral.rcall5   sD    DHH((4.C((..&CtDz#t{{++r(   c                 H    | j                    }t        | j                  |      S r*   )r#   r   r"   )r,   r#   s     r'   
__invert__zLiteral.__invert__<   s    [[txx((r(   c                 v    dj                  t        |       j                  | j                  | j                        S )Nz
{}({}, {}))formatr1   __name__r"   r#   r+   s    r'   __str__zLiteral.__str__@   s)    ""4:#6#6$++NNr(   c                 j    | j                   |j                   k(  xr | j                  |j                  k(  S r*   )r-   r#   r,   others     r'   __eq__zLiteral.__eq__E   s'    xx599$D)DDr(   c                 p    t        t        |       j                  | j                  | j                  f      }|S r*   )hashr1   r8   r-   r#   )r,   hs     r'   __hash__zLiteral.__hash__H   s*    $t*%%txx=>r(   )F)r8   
__module____qualname____doc__r!   propertyr-   r3   r5   r9   __repr__r=   rA   __classcell__)r&   s   @r'   r   r      sC    ,	  ,)O HEr(   r   c                   H    e Zd ZdZd Zed        Zd Zd Zd Z	d Z
d ZeZy	)
r   z+
    A low-level implementation for Or
    c                     || _         y r*   _argsr,   r   s     r'   __init__zOR.__init__Q   	    
r(   c                 8    t        | j                  t              S N)keysortedrK   strr+   s    r'   r   zOR.argsT       djjc**r(   c                 v     t        |       | j                  D cg c]  }|j                  |       c} S c c}w r*   r1   rK   r3   r,   r2   r-   s      r'   r3   zOR.rcallX   <    tDz'+zz #  IIdO   	    6c                 N    t        | j                  D cg c]  }|  c} S c c}w r*   )r   rK   r,   r-   s     r'   r5   zOR.__invert__]   s!    TZZ0ccT0110   
"c                 l    t        t        |       j                  ft        | j                        z         S r*   r?   r1   r8   tupler   r+   s    r'   rA   zOR.__hash__`   (    T$Z((*U499-==>>r(   c                 4    | j                   |j                   k(  S r*   r   r;   s     r'   r=   z	OR.__eq__c       yyEJJ&&r(   c           	          ddj                  | j                  D cg c]  }t        |       c}      z   dz   }|S c c}w )N( | )joinr   rT   r,   r-   ss      r'   r9   z
OR.__str__f   s7    %**$))<3c#h<==C =   ;
N)r8   rB   rC   rD   rM   rE   r   r3   r5   rA   r=   r9   rF    r(   r'   r   r   M   s@     + +
2?' Hr(   r   c                   H    e Zd ZdZd Zd Zed        Zd Zd Z	d Z
d ZeZy	)
r   z,
    A low-level implementation for And
    c                     || _         y r*   rJ   rL   s     r'   rM   zAND.__init__q   rN   r(   c                 N    t        | j                  D cg c]  }|  c} S c c}w r*   )r   rK   r\   s     r'   r5   zAND.__invert__t   s!    DJJ/SSD/00/r]   c                 8    t        | j                  t              S rP   rR   r+   s    r'   r   zAND.argsw   rU   r(   c                 v     t        |       | j                  D cg c]  }|j                  |       c} S c c}w r*   rW   rX   s      r'   r3   z	AND.rcall{   rY   rZ   c                 l    t        t        |       j                  ft        | j                        z         S r*   r_   r+   s    r'   rA   zAND.__hash__   ra   r(   c                 4    | j                   |j                   k(  S r*   rc   r;   s     r'   r=   z
AND.__eq__   rd   r(   c           	          ddj                  | j                  D cg c]  }t        |       c}      z   dz   }|S c c}w )Nrf    & rh   ri   rk   s      r'   r9   zAND.__str__   s7    

		:CH:;;C? ;rm   N)r8   rB   rC   rD   rM   r5   rE   r   r3   rA   r=   r9   rF   rn   r(   r'   r   r   m   s@    1 + +
?' Hr(   r   Nc                 .
   ddl m} |i }t        |j                  t        |j
                  t        |j                  t        |j                  t        |j                  t        |j                  i}t        |       |v r|t        |          } || j                   } t!        | t"              r| j                  d   }t%        ||      }| S t!        | t&              r3t)        t'        j*                  |       D cg c]  }t%        ||       c} S t!        | t,              r3t/        t-        j*                  |       D cg c]  }t%        ||       c} S t!        | t0              r-t/        | j                  D cg c]  }t%        ||       c} }| S t!        | t2              r-t)        | j                  D cg c]  }t%        ||       c} }| S t!        | t4              rg }t7        dt9        | j                        dz   d      D ]h  }	t;        | j                  |	      D ]M  }
| j                  D cg c]  }||
v rt%        ||       nt%        ||      ! }}|j=                  t)        |        O j t/        | S t!        | t>              rg }t7        dt9        | j                        dz   d      D ]h  }	t;        | j                  |	      D ]M  }
| j                  D cg c]  }||
v rt%        ||       nt%        ||      ! }}|j=                  t)        |        O j t/        |  S t!        | t@              r?t%        | j                  d   |      t%        | j                  d   |      }}t)        | |      S t!        | tB              rxg }tE        | j                  | j                  dd | j                  d         D ]9  \  }}t%        ||      }t%        ||      }|j=                  t)        | |             ; t/        | S t!        | tF              rlt%        | j                  d   |      }t%        | j                  d   |      }t%        | j                  d   |      }t/        t)        | |      t)        ||            S t!        | tH              rE| jJ                  | jL                  }}|jO                  |d      }|t%         |jP                  | |      S t!        | tR              r |jO                  | d      }|t%        ||      S tU        |       S c c}w c c}w c c}w c c}w c c}w c c}w )a  
    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.askry   r   eqr	   ner
   gtr   ltr   ger   ler1   r   r   r   to_NNFr   r   	make_argsr   r   r   r   r   rangelenr   appendr   r   r   r   r   r   function	argumentsgetr3   r   r   )r2   composite_mapry   binrelpredspredr-   tmpxcnfsinegrl   clauseLRabMr   newpreds                       r'   r   r      so   : ( qttRr144QTT2qttRNKDz[ 4:&TYY$iilS-(t$bll46HIF1m,IJJ$s}}T7JK!VA}-KLL$dii@F1m,@At$TYY?6!]+?@t$q#dii.1,a0 	)A#DIIq1 )#'99. 89Cx6!]33VA}E]] . .BK()	)
 Dz$q#dii.1,a0 	)A#DIIq1 )#'99. 89Cx6!]33VA}E]] . .BK()	)
 T
{$ diilM2F499Q<4W11"ay$
#		499QR=DIIaLQ 	#DAqq-(Aq-(AKKA2q	"	# Dz$499Q</499Q</499Q</2qb!9bAh''$()]]DNNd##D$/-'--.>>$	"##D$/'=114=y J L A @..s$   1S94S>.T+T$$T$Tc                    t        | t        t        f      s0t               }|j	                  t        | f             t        |      S t        | t              r3t        j                  | j                  D cg c]  }t        |       c} S t        | t              r3t        j                  | j                  D cg c]  }t        |       c} S yc c}w c c}w )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_orrK   distribute_AND_over_ORall_and)r2   r   r-   s      r'   r   r      s     dS"I&e	4'"#3x$zz'+zz3 # 337 3 4 	4 ${{(,

4!$ 4C8 4 5 	5 34s   4C7Cc                       e Zd ZdZddZd Zd Zd Zd Zd Z	e
d	        Zd
 Zd Zd Zd Zd Zd Ze
d        Ze
d        Ze
d        Ze
d        Zy)r   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                 *    |s
t               }|| _        y r*   )r   clausesr,   r   s     r'   rM   zCNF.__init__   s    eGr(   c                 d    t         j                  |      j                  }| j                  |       y r*   )r   to_CNFr   add_clauses)r,   propr   s      r'   r   zCNF.add%  s$    **T"**!r(   c                     dj                  | j                  D cg c]0  }ddj                  |D cg c]  }t        |       c}      z   dz   2 c}}      }|S c c}w c c}}w )Nrw   rf   rg   rh   )rj   r   rT   )r,   r   r"   rl   s       r'   r9   zCNF.__str__)  s]    JJ,,( 5::6:Cs3x:;;S@ (
  ; (s   A
AA
A
c                 6    |D ]  }| j                  |        | S r*   r   )r,   propsps      r'   extendz
CNF.extend0  s!     	AHHQK	r(   c                 >    t        t        | j                              S r*   )r   r   r   r+   s    r'   copyzCNF.copy5  s    3t||$%%r(   c                 .    | xj                   |z  c_         y r*   )r   r   s     r'   r   zCNF.add_clauses8  s    r(   c                 6     |        }|j                  |       |S r*   r   )r$   r   ress      r'   	from_propzCNF.from_prop;  s    e
r(   c                 <    | j                  |j                         | S r*   )r   r   r;   s     r'   __iand__zCNF.__iand__A  s    'r(   c                     t               }| j                  D ]  }||D ch c]  }|j                   c}z  }! |S c c}w r*   )r   r   r"   )r,   
predicatescr-   s       r'   all_predicateszCNF.all_predicatesE  s@    U
 	1Aa0s37700J	1 1s   ;c                     t               }t        | j                  |j                        D ];  \  }}t        |      }|j                  |       |j	                  t        |             = t        |      S r*   )r   r   r   updater   r   r   )r,   cnfr   r   r   r   s         r'   _orzCNF._orK  s[    %DLL#++6 	(DAqa&CJJqMKK	#'	( 7|r(   c                 b    | j                   j                  |j                         }t        |      S r*   )r   unionr   )r,   r   r   s      r'   _andzCNF._andS  s$    ,,$$S[[17|r(   c                    t        | j                        }|d   D ch c]  }t        | f       }}t        |      }|d d D ]6  }|D ch c]  }t        | f       }}|j	                  t        |            }8 |S c c}w c c}w )N)listr   r   r   r   )r,   clssr   llrestr   s         r'   _notzCNF._notW  s    DLL!(,R11i!11W"I 	 D+/0aQB5!0A0AB	  	 2 1s   A>
Bc                     g }| j                   D ]7  }|D cg c]  }|j                  |       }}|j                  t        |        9 t	        | }t        |      S c c}w r*   )r   r3   r   r   r   r   )r,   r2   clause_listr   r-   litss         r'   r3   z	CNF.rcalla  sc    ll 	*F/56CIIdO6D6r4y)	* K %d++ 7s   Ac                 b    |d   j                         }|dd  D ]  }|j                  |      } |S Nr   rz   )r   r   r$   r   r   r   s       r'   r   z
CNF.all_ori  s8    GLLNH 	DdA	r(   c                 b    |d   j                         }|dd  D ]  }|j                  |      } |S r   )r   r   r   s       r'   r   zCNF.all_andp  s8    GLLNH 	DtA	r(   c                 J    ddl m} t        | |             }t        |      }|S )Nr   )get_composite_predicates)sympy.assumptions.factsr   r   r   )r$   r2   r   s      r'   r   z
CNF.to_CNFw  s$    Dd467%d+r(   c                 @    d t        fd|j                  D         S )zm
        Converts CNF object to SymPy's boolean expression
        retaining the form of expression.
        c                 \    | j                   rt        | j                        S | j                  S r*   )r#   r   r"   )r-   s    r'   remove_literalz&CNF.CNF_to_cnf.<locals>.remove_literal  s    #&::3sww<:377:r(   c              3   @   K   | ]  }t        fd |D           yw)c              3   .   K   | ]  } |        y wr*   rn   ).0r-   r   s     r'   	<genexpr>z+CNF.CNF_to_cnf.<locals>.<genexpr>.<genexpr>  s     @#.-@s   N)r   )r   r   r   s     r'   r   z!CNF.CNF_to_cnf.<locals>.<genexpr>  s     \fR@@A\s   )r   r   )r$   r   r   s     @r'   
CNF_to_cnfzCNF.CNF_to_cnf~  s"    	; \PSP[P[\]]r(   r*   )r8   rB   rC   rD   rM   r   r9   r   r   r   classmethodr   r   r   r   r   r   r3   r   r   r   r   rn   r(   r'   r   r     s    "
"
&   
,       ^ ^r(   r   c                   \    e Zd ZdZddZd Zed        Zed        Zd Z	d Z
d	 Zd
 Zd Zy)
EncodedCNFz0
    Class for encoding the CNF expression.
    Nc                 l    |s|sg }i }|| _         || _        t        |j                               | _        y r*   )dataencodingr   keys_symbols)r,   r   r   s      r'   rM   zEncodedCNF.__init__  s1    HDH	 X]]_-r(   c           
      2   t        |j                               | _        t        | j                        }t	        t        | j                  t        d|dz                     | _        |j                  D cg c]  }| j                  |       c}| _
        y c c}w Nrz   )r   r   r   r   dictzipr   r   r   encoder   )r,   r   nr   s       r'   from_cnfzEncodedCNF.from_cnf  sh    S//12SaQ@A7:{{CVT[[(C	Cs   3Bc                     | j                   S r*   )r   r+   s    r'   symbolszEncodedCNF.symbols  s    }}r(   c                 F    t        dt        | j                        dz         S r   )r   r   r   r+   s    r'   	variableszEncodedCNF.variables  s    QDMM*Q.//r(   c                     | j                   D cg c]  }t        |       }}t        |t        | j                              S c c}w r*   )r   r   r   r   r   )r,   r   new_datas      r'   r   zEncodedCNF.copy  s8    .2ii8FCK88(D$788 9s   Ac                 P    t         j                  |      }| j                  |       y r*   )r   r   add_from_cnf)r,   r   r   s      r'   add_propzEncodedCNF.add_prop  s    mmD!#r(   c                     |j                   D cg c]  }| j                  |       }}| xj                  |z  c_        y c c}w r*   )r   r   r   )r,   r   r   r   s       r'   r   zEncodedCNF.add_from_cnf  s6    58[[A64;;v&AA		W	 Bs   ?c                     |j                   }| j                  j                  |d       }|Dt        | j                        }| j                  j                  |       |dz   x}| j                  |<   |j                  r| S |S r   )r"   r   r   r   r   r   r#   )r,   r-   literalvaluer   s        r'   
encode_argzEncodedCNF.encode_arg  sp    ''!!'40=DMM"AMM  )-.U2EDMM'*::6MLr(   c                     |D ch c]2  }|j                   t        j                  k(  s| j                  |      nd4 c}S c c}w )Nr   )r"   r   falser   )r,   r   r-   s      r'   r   zEncodedCNF.encode  s3    QWX#CGGqww,>$AEXXXs   7?)NN)r8   rB   rC   rD   rM   r   rE   r   r   r   r   r   r   r   rn   r(   r'   r   r     sT    .D   0 09
Yr(   r   r*   )#rD   	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   rn   r(   r'   <module>r     sr    9 8 @ 8 8 " 2 2 J J; ;| @ @jZ5(y^ y^x3Y 3Yr(   