
    MZd1                        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       7/usr/lib/python3/dist-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 # t        $ r | j                  j	                  |      }Y Bw xY wr*   )callabler"   applyAttributeErrorrcalltyper#   )r,   exprr"   s      r'   r2   zLiteral.rcall5   sn    DHH((4.C+hhnnT* tDz#t{{++ " +hhnnT*+s   A   $BB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
{}({}, {}))formatr3   __name__r"   r#   r+   s    r'   __str__zLiteral.__str__C   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__H   s'    xx599$D)DDr(   c                 p    t        t        |       j                  | j                  | j                  f      }|S r*   )hashr3   r9   r-   r#   )r,   hs     r'   __hash__zLiteral.__hash__K   s*    $t*%%txx=>r(   )F)r9   
__module____qualname____doc__r!   propertyr-   r2   r6   r:   __repr__r>   rB   __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__T   	    
r(   c                 8    t        | j                  t              S N)keysortedrL   strr+   s    r'   r   zOR.argsW       djjc**r(   c                 v     t        |       | j                  D cg c]  }|j                  |       c} S c c}w r*   r3   rL   r2   r,   r4   r-   s      r'   r2   zOR.rcall[   <    tDz'+zz #  IIdO   	    6c                 N    t        | j                  D cg c]  }|  c} S c c}w r*   )r   rL   r,   r-   s     r'   r6   zOR.__invert__`   s!    TZZ0ccT0110   
"c                 l    t        t        |       j                  ft        | j                        z         S r*   r@   r3   r9   tupler   r+   s    r'   rB   zOR.__hash__c   (    T$Z((*U499-==>>r(   c                 4    | j                   |j                   k(  S r*   r   r<   s     r'   r>   z	OR.__eq__f       yyEJJ&&r(   c           	          ddj                  | j                  D cg c]  }t        |       c}      z   dz   }|S c c}w )N( | )joinr   rU   r,   r-   ss      r'   r:   z
OR.__str__i   s7    %**$))<3c#h<==C =   ;
N)r9   rC   rD   rE   rN   rF   r   r2   r6   rB   r>   r:   rG    r(   r'   r   r   P   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*   rK   rM   s     r'   rN   zAND.__init__t   rO   r(   c                 N    t        | j                  D cg c]  }|  c} S c c}w r*   )r   rL   r]   s     r'   r6   zAND.__invert__w   s!    DJJ/SSD/00/r^   c                 8    t        | j                  t              S rQ   rS   r+   s    r'   r   zAND.argsz   rV   r(   c                 v     t        |       | j                  D cg c]  }|j                  |       c} S c c}w r*   rX   rY   s      r'   r2   z	AND.rcall~   rZ   r[   c                 l    t        t        |       j                  ft        | j                        z         S r*   r`   r+   s    r'   rB   zAND.__hash__   rb   r(   c                 4    | j                   |j                   k(  S r*   rd   r<   s     r'   r>   z
AND.__eq__   re   r(   c           	          ddj                  | j                  D cg c]  }t        |       c}      z   dz   }|S c c}w )Nrg    & ri   rj   rl   s      r'   r:   zAND.__str__   s7    

		:CH:;;C? ;rn   N)r9   rC   rD   rE   rN   r6   rF   r   r2   rB   r>   r:   rG   ro   r(   r'   r   r   p   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.askrz   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getr2   r   r   )r4   composite_maprz   binrelpredspredr-   tmpxcnfsinegrm   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_orrL   distribute_AND_over_ORall_and)r4   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'   rN   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 )Nrx   rg   rh   ri   )rk   r   rU   )r,   r   r"   rm   s       r'   r:   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.extend3  s!     	AHHQK	r(   c                 >    t        t        | j                              S r*   )r   r   r   r+   s    r'   copyzCNF.copy8  s    3t||$%%r(   c                 .    | xj                   |z  c_         y r*   )r   r   s     r'   r   zCNF.add_clauses;  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__D  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_predicatesH  s@    U
 	1Aa0s37700J	1 1s   ;c                     t               }t        | j                  |j                        D ]B  \  }}t        |      }|D ]  }|j                  |        |j                  t	        |             D t        |      S r*   )r   r   r   r   r   r   )r,   cnfr   r   r   r   ts          r'   _orzCNF._orN  sj    %DLL#++6 	(DAqa&C 
KK	#'		(
 7|r(   c                 b    | j                   j                  |j                         }t        |      S r*   )r   unionr   )r,   r   r   s      r'   _andzCNF._andW  s$    ,,$$S[[17|r(   c                 H   t        | j                        }t               }|d   D ]  }|j                  t	        | f               t        |      }|d d D ]I  }t               }|D ]  }|j                  t	        | f               |j                  t        |            }K |S )N)listr   r   r   r   r   r   )r,   clssllr   restr   s         r'   _notzCNF._not[  s    DLL!Ub 	%AFF9qbU#$	%W"I 	 DA (i!&'(AB		 
 	r(   c                     g }| j                   D ]7  }|D cg c]  }|j                  |       }}|j                  t        |        9 t	        | }t        |      S c c}w r*   )r   r2   r   r   r   r   )r,   r4   clause_listr   r-   litss         r'   r2   z	CNF.rcalli  sc    ll 	*F/56CIIdO6D6r4y)	* K %d++ 7s   Ac                 b    |d   j                         }|dd  D ]  }|j                  |      } |S Nr   r{   )r   r   r$   r   r   r   s       r'   r   z
CNF.all_orq  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_andx  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$   r4   r   s      r'   r   z
CNF.to_CNF  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*   ro   ).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*   )r9   rC   rD   rE   rN   r   r:   r   r   r   classmethodr   r   r   r   r   r   r2   r   r   r   r   ro   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'   rN   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 Nr{   )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)r9   rC   rD   rE   rN   r   rF   r   r   r   r   r   r   r   ro   r(   r'   r   r     sT    .D   0 09
Yr(   r   r*   )#rE   	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   ro   r(   r'   <module>r     sr    9 8 @ 8 8 " 2 2 J J> >B @ @jZ5(~^ ~^B3Y 3Yr(   