
    Ed1                     "   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"dS )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                   \     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)
    Fc                    t          |t                    r|j        d         }d}n)t          |t          t          t
          f          r|r| n|S t                                          |           }||_        ||_	        |S )Nr   T)

isinstancer   argsANDORr   super__new__litis_Not)clsr"   r#   obj	__class__s       5lib/python3.11/site-packages/sympy/assumptions/cnf.pyr!   zLiteral.__new__&   sy    c3 	+(1+CFFc2w/00 	+!*C44s*ggooc""

    c                     | j         S Nr"   selfs    r'   argzLiteral.arg1   s	    xr(   c                    t          | j                  r|                     |          }nF	 | j                            |          }n*# t          $ r | j                            |          }Y nw xY w t          |           || j                  S r*   )callabler"   applyAttributeErrorrcalltyper#   )r-   exprr"   s      r'   r3   zLiteral.rcall5   s    DH 	+((4..CC+hnnT**! + + +hnnT**+tDzz#t{+++s   A $A.-A.c                 <    | j          }t          | j        |          S r*   )r#   r   r"   )r-   r#   s     r'   
__invert__zLiteral.__invert__?   s    [tx(((r(   c                 h    d                     t          |           j        | j        | j                  S )Nz
{}({}, {}))formatr4   __name__r"   r#   r,   s    r'   __str__zLiteral.__str__C   s'    ""4::#6$+NNNr(   c                 B    | j         |j         k    o| j        |j        k    S r*   )r.   r#   r-   others     r'   __eq__zLiteral.__eq__H   s    x59$D)DDr(   c                 b    t          t          |           j        | j        | j        f          }|S r*   )hashr4   r:   r.   r#   )r-   hs     r'   __hash__zLiteral.__hash__K   s(    $t**%tx=>>r(   )F)r:   
__module____qualname____doc__r!   propertyr.   r3   r7   r;   __repr__r?   rC   __classcell__)r&   s   @r'   r   r      s         ,	 	 	 	 	 	   X, , ,) ) )O O O HE E E      r(   r   c                   P    e Zd ZdZd Zed             Zd Zd Zd Z	d Z
d ZeZd	S )
r   z+
    A low-level implementation for Or
    c                     || _         d S r*   _argsr-   r   s     r'   __init__zOR.__init__T       


r(   c                 8    t          | j        t                    S N)keysortedrM   strr,   s    r'   r   zOR.argsW       djc****r(   c                 J     t          |           fd| j        D              S )Nc                 :    g | ]}|                               S  r3   .0r.   r5   s     r'   
<listcomp>zOR.rcall.<locals>.<listcomp>\   3        #  IIdOO   r(   r4   rM   r-   r5   s    `r'   r3   zOR.rcall[   @    tDzz    '+z    	r(   c                 2    t          d | j        D              S )Nc                     g | ]}| S rZ   rZ   r]   r.   s     r'   r^   z!OR.__invert__.<locals>.<listcomp>a   s    000ccT000r(   )r   rM   r,   s    r'   r7   zOR.__invert__`   s    00TZ00011r(   c                 p    t          t          |           j        ft          | j                  z             S r*   rA   r4   r:   tupler   r,   s    r'   rC   zOR.__hash__c   +    T$ZZ(*U49-=-==>>>r(   c                 "    | j         |j         k    S r*   r   r=   s     r'   r?   z	OR.__eq__f       yEJ&&r(   c                 Z    dd                     d | j        D                       z   dz   }|S )N( | c                 ,    g | ]}t          |          S rZ   rV   re   s     r'   r^   zOR.__str__.<locals>.<listcomp>j   s    <<<3c#hh<<<r(   )joinr   r-   ss     r'   r;   z
OR.__str__i   s3    %**<<$)<<<===Cr(   N)r:   rD   rE   rF   rO   rG   r   r3   r7   rC   r?   r;   rH   rZ   r(   r'   r   r   P   s            + + X+  
2 2 2? ? ?' ' '   HHHr(   r   c                   P    e Zd ZdZd Zd Zed             Zd Zd Z	d Z
d ZeZd	S )
r   z,
    A low-level implementation for And
    c                     || _         d S r*   rL   rN   s     r'   rO   zAND.__init__t   rP   r(   c                 2    t          d | j        D              S )Nc                     g | ]}| S rZ   rZ   re   s     r'   r^   z"AND.__invert__.<locals>.<listcomp>x   s    ///SSD///r(   )r   rM   r,   s    r'   r7   zAND.__invert__w   s    //DJ///00r(   c                 8    t          | j        t                    S rR   rT   r,   s    r'   r   zAND.argsz   rW   r(   c                 J     t          |           fd| j        D              S )Nc                 :    g | ]}|                               S rZ   r[   r\   s     r'   r^   zAND.rcall.<locals>.<listcomp>   r_   r(   r`   ra   s    `r'   r3   z	AND.rcall~   rb   r(   c                 p    t          t          |           j        ft          | j                  z             S r*   rg   r,   s    r'   rC   zAND.__hash__   ri   r(   c                 "    | j         |j         k    S r*   rk   r=   s     r'   r?   z
AND.__eq__   rl   r(   c                 Z    dd                     d | j        D                       z   dz   }|S )Nrn    & c                 ,    g | ]}t          |          S rZ   rq   re   s     r'   r^   zAND.__str__.<locals>.<listcomp>   s    :::CHH:::r(   rr   rs   ru   s     r'   r;   zAND.__str__   s3    

::	:::;;;C?r(   N)r:   rD   rE   rF   rO   r7   rG   r   r3   rC   r?   r;   rH   rZ   r(   r'   r   r   p   s           1 1 1 + + X+  
? ? ?' ' '   HHHr(   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&                    r't)          fdt'          j        |           D              S t!          | t,                    r't/          fdt-          j        |           D              S t!          | t0                    rt/          fd| j        D              }| S t!          | t2                    rt)          fd| j        D              }| S t!          | t4                    r|g }t7          dt9          | j                  dz   d	          D ]J}t;          | j        |          D ]2fd
| j        D             }	|                    t)          |	            3Kt/          | S t!          | t>                    r}g }t7          dt9          | j                  dz   d	          D ]J}t;          | j        |          D ]2fd| j        D             }	|                    t)          |	            3Kt/          |  S t!          | t@                    rGt%          | j        d                   t%          | j        d                   }}
t)          |
 |          S t!          | tB                    rg }tE          | j        | j        dd         | j        d                   D ]I\  }}t%          |          }t%          |          }|                    t)          | |                     Jt/          | S t!          | tF                    r~t%          | j        d                   }
t%          | j        d                   }t%          | j        d	                   }t/          t)          |
 |          t)          |
|                    S t!          | tH                    r>| j%        | j&        }}'                    |d          }|t%           |j(        |           S t!          | tR                    r('                    | d          }|t%          |          S tU          |           S )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   )QNc                 0    g | ]}t          |          S rZ   to_NNFr]   xcomposite_maps     r'   r^   zto_NNF.<locals>.<listcomp>   s#    IIIF1m,,IIIr(   c                 0    g | ]}t          |          S rZ   r   r   s     r'   r^   zto_NNF.<locals>.<listcomp>   s#    KKK!VA}--KKKr(   c                 0    g | ]}t          |          S rZ   r   r   s     r'   r^   zto_NNF.<locals>.<listcomp>   s#    @@@F1m,,@@@r(   c                 0    g | ]}t          |          S rZ   r   r   s     r'   r^   zto_NNF.<locals>.<listcomp>   s#    ???6!]++???r(         c                 Z    g | ]'}|v rt          |           nt          |          (S rZ   r   r]   rv   r   negs     r'   r^   zto_NNF.<locals>.<listcomp>   N     . . . 89Cx]6!]3333VA}E]E] . . .r(   c                 Z    g | ]'}|v rt          |           nt          |          (S rZ   r   r   s     r'   r^   zto_NNF.<locals>.<listcomp>   r   r(   )	fillvalue)+sympy.assumptions.askr   r   eqr	   ner
   gtr   ltr   ger   ler4   r   r   r   r   r   r   	make_argsr   r   r   r   r   rangelenr   appendr   r   r   r   r   r   function	argumentsgetr3   r   r   )r5   r   r   binrelpredspredr.   tmpcnfsiclauseLRabMr   newpredr   s    `               @r'   r   r      s   : ('''''  qtRr14QT2qtRNKDzz[   4::&tTY$ ilS-((t$ KIIIIbl46H6HIIIJJ$ MKKKKs}T7J7JKKKLL$ @@@@di@@@At$ ????TY???@t$ q#di..1,a00 	) 	)A#DIq11 ) ). . . . .#'9. . .BK(((() Dz$ q#di..1,a00 	) 	)A#DIq11 ) ). . . . .#'9. . .BK(((() T
{$   dilM22F49Q<4W4W11"ayy$
## 	49QRR=DIaLQQQ 	# 	#DAqq-((Aq-((AKKA2q		""""Dz$ (49Q<//49Q<//49Q<//2qb!99bAhh'''$()) ?]DNd##D$// 	?-'-.>>>$	"" 2##D$// 	2'=1114==r(   c                    t          | t          t          f          s@t                      }|                    t          | f                     t          |          S t          | t                    rt          j        d | j        D              S t          | t                    rt          j	        d | j        D              S dS )z
    Distributes AND over OR in the NNF expression.
    Returns the result( Conjunctive Normal Form of expression)
    as a CNF object.
    c                 ,    g | ]}t          |          S rZ   distribute_AND_over_ORre   s     r'   r^   z*distribute_AND_over_OR.<locals>.<listcomp>	  s0     3 3 3 # 3377 3 3 3r(   c                 ,    g | ]}t          |          S rZ   r   re   s     r'   r^   z*distribute_AND_over_OR.<locals>.<listcomp>  s0     4 4 4!$ 4C88 4 4 4r(   N)
r   r   r   setadd	frozensetCNFall_orrM   all_and)r5   r   s     r'   r   r      s     dS"I&& ee	4'""###3xx$ 4z 3 3'+z3 3 3 4 	4 $ 5{ 4 4(,
4 4 4 5 	55 5r(   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dS )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                 4    |st                      }|| _        d S r*   r   clausesr-   r   s     r'   rO   zCNF.__init__#  s     	eeGr(   c                 n    t                               |          j        }|                     |           d S r*   )r   to_CNFr   add_clauses)r-   propr   s      r'   r   zCNF.add(  s0    **T""*!!!!!r(   c                 N    d                     d | j        D                       }|S )Nr   c                 X    g | ]'}d d                     d |D                       z   dz   (S )rn   ro   c                 ,    g | ]}t          |          S rZ   rq   )r]   r"   s     r'   r^   z*CNF.__str__.<locals>.<listcomp>.<listcomp>.  s    :::Cs3xx:::r(   rr   )rt   r]   r   s     r'   r^   zCNF.__str__.<locals>.<listcomp>.  sM     ( ( ( 5::::6:::;;;S@ ( ( (r(   )rt   r   ru   s     r'   r;   zCNF.__str__,  s:    JJ( (,( ( (
 
 r(   c                 :    |D ]}|                      |           | S r*   r   )r-   propsps      r'   extendz
CNF.extend3  s'     	 	AHHQKKKKr(   c                 D    t          t          | j                            S r*   )r   r   r   r,   s    r'   copyzCNF.copy8  s    3t|$$%%%r(   c                 &    | xj         |z  c_         d S r*   )r   r   s     r'   r   zCNF.add_clauses;  s    r(   c                 D     |             }|                     |           |S r*   r   )r$   r   ress      r'   	from_propzCNF.from_prop>  s!    cee
r(   c                 :    |                      |j                   | S r*   )r   r   r=   s     r'   __iand__zCNF.__iand__D  s    '''r(   c                 T    t                      }| j        D ]}|d |D             z  }|S )Nc                     h | ]	}|j         
S rZ   r+   re   s     r'   	<setcomp>z%CNF.all_predicates.<locals>.<setcomp>K  s    000s37000r(   r   )r-   
predicatescs      r'   all_predicateszCNF.all_predicatesH  s=    UU
 	1 	1A00a0000JJr(   c                    t                      }t          | j        |j                  D ]P\  }}t          |          }|D ]}|                    |           |                    t	          |                     Qt          |          S r*   )r   r   r   r   r   r   )r-   cnfr   r   r   r   ts          r'   _orzCNF._orN  s~    %%DL#+66 	( 	(DAqa&&C  



KK	#''''7||r(   c                 ^    | j                             |j                   }t          |          S r*   )r   unionr   r-   r   r   s      r'   _andzCNF._andW  s%    ,$$S[117||r(   c                    t          | j                  }t                      }|d         D ]&}|                    t	          | f                     't          |          }|d d         D ][}t                      }|D ]&}|                    t	          | f                     '|                    t          |                    }\|S )N)listr   r   r   r   r   r   )r-   clssllr   restr   s         r'   _notzCNF._not[  s    DL!!UUb 	% 	%AFF9qbU##$$$$WW"I 	  	 DA ( (i!&&''''ABB	r(   c                     t                      }| j        D ],}fd|D             }|                    t          |            -t	          | t                    S )Nc                 :    g | ]}|                               S rZ   r[   r\   s     r'   r^   zCNF.rcall.<locals>.<listcomp>l  s#    666CIIdOO666r(   )r   r   r   r   r   r   )r-   r5   clause_listr   litss    `   r'   r3   z	CNF.rcalli  si    ffl 	* 	*F6666v666Dr4y))))K %d+++r(   c                 ~    |d                                          }|dd          D ]}|                    |          }|S Nr   r   )r   r   r$   r   r   r   s       r'   r   z
CNF.all_orq  s@    GLLNNH 	 	DdAAr(   c                 ~    |d                                          }|dd          D ]}|                    |          }|S r   )r   r   r   s       r'   r   zCNF.all_andx  s@    GLLNNH 	 	DtAAr(   c                 `    ddl m} t          | |                      }t          |          }|S )Nr   )get_composite_predicates)sympy.assumptions.factsr   r   r   )r$   r5   r   s      r'   r   z
CNF.to_CNF  s?    DDDDDDd44667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                 F    | j         rt          | j                  n| j        S r*   )r#   r   r"   )r.   s    r'   remove_literalz&CNF.CNF_to_cnf.<locals>.remove_literal  s    #&::3sw<<<37:r(   c              3   B   K   | ]}t          fd |D              V  dS )c              3   .   K   | ]} |          V  d S r*   rZ   )r]   r.   r   s     r'   	<genexpr>z+CNF.CNF_to_cnf.<locals>.<genexpr>.<genexpr>  s-      @@#..--@@@@@@r(   N)r   )r]   r   r   s     r'   r   z!CNF.CNF_to_cnf.<locals>.<genexpr>  s=      \\fR@@@@@@@A\\\\\\r(   )r   r   )r$   r   r   s     @r'   
CNF_to_cnfzCNF.CNF_to_cnf  s8    	; 	; 	; \\\\PSP[\\\]]r(   r*   )r:   rD   rE   rF   rO   r   r;   r   r   r   classmethodr   r   r   r   r   r   r3   r   r   r   r   rZ   r(   r'   r   r     sc        "   
" " "    
& & &        [
          , , ,   [   [   [ ^ ^ [^ ^ ^r(   r   c                   j    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dS )
EncodedCNFz0
    Class for encoding the CNF expression.
    Nc                 ~    |s|sg }i }|| _         || _        t          |                                          | _        d S r*   )dataencodingr   keys_symbols)r-   r   r  s      r'   rO   zEncodedCNF.__init__  sD     	H 	DH	 X]]__--r(   c                 P    t          |                                           _        t           j                  }t	          t          t           j        t          t          d|dz                                                      _         fd|j        D              _	        d S )Nr   c                 :    g | ]}                     |          S rZ   encoder]   r   r-   s     r'   r^   z'EncodedCNF.from_cnf.<locals>.<listcomp>  s%    CCCVT[[((CCCr(   )
r   r   r  r   dictzipr   r  r   r   )r-   r   ns   `  r'   from_cnfzEncodedCNF.from_cnf  s    S//1122T#dmT%1q5//5J5J"K"KLLMMCCCCs{CCC			r(   c                     | j         S r*   )r  r,   s    r'   symbolszEncodedCNF.symbols  s
    }r(   c                 L    t          dt          | j                  dz             S Nr   )r   r   r  r,   s    r'   	variableszEncodedCNF.variables  s!    QDM**Q.///r(   c                 h    d | j         D             }t          |t          | j                            S )Nc                 ,    g | ]}t          |          S rZ   )r   r   s     r'   r^   z#EncodedCNF.copy.<locals>.<listcomp>  s    888FCKK888r(   )r   r   r	  r  )r-   new_datas     r'   r   zEncodedCNF.copy  s1    88di888(D$7$7888r(   c                 d    t                               |          }|                     |           d S r*   )r   r   add_from_cnf)r-   r   r   s      r'   add_propzEncodedCNF.add_prop  s-    mmD!!#r(   c                 N      fd|j         D             } xj        |z  c_        d S )Nc                 :    g | ]}                     |          S rZ   r  r  s     r'   r^   z+EncodedCNF.add_from_cnf.<locals>.<listcomp>  s%    AAA64;;v&&AAAr(   )r   r   r   s   `  r'   r  zEncodedCNF.add_from_cnf  s2    AAAAS[AAA		W				r(   c                     |j         }| j                            |d           }|=t          | 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  sx    '!!'400 	3DM""AM  )))-.U2EDM'*: 	6MLr(   c                        fd|D             S )Nc                 h    h | ].}|j         t          j        k    s                    |          nd /S )r   )r"   r   falser  )r]   r.   r-   s     r'   r   z$EncodedCNF.encode.<locals>.<setcomp>  s8    XXX#CGqw,>E$$$AXXXr(   rZ   )r-   r   s   ` r'   r  zEncodedCNF.encode  s    XXXXQWXXXXr(   )NN)r:   rD   rE   rF   rO   r  rG   r  r  r   r  r  r  r  rZ   r(   r'   r   r     s         . . . .D D D   X 0 0 X09 9 9    
 
 
Y Y Y Y Yr(   r   r*   )#rF   	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   rZ   r(   r'   <module>r&     s    9 8 8 8 8 8 8 8 8 8 @ @ @ @ @ @ @ @ 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 " " " " " " 2 2 2 2 2 2 2 2 2 2 2 2 J J J J J J J J J J J J J J J J> > > > > > > >B       @       @j j j jZ5 5 5(~^ ~^ ~^ ~^ ~^ ~^ ~^ ~^B3Y 3Y 3Y 3Y 3Y 3Y 3Y 3Y 3Y 3Yr(   