U
    ZÊ¹jÝ0  ã                   @   sè   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	„ d	ƒZG d
d„ dƒZG dd„ dƒZddd„Zdd„ Z G dd„ dƒZ!G d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                       sZ   e Zd ZdZd‡ fdd„	Zedd„ ƒZdd„ Zd	d
„ Zdd„ Z	e	Z
dd„ Zdd„ Z‡  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                    sT   t |tƒr|jd }d}nt |tttfƒr8|r4| S |S tƒ  | ¡}||_||_	|S )Nr   T)
Ú
isinstancer   ÚargsÚANDÚORr   ÚsuperÚ__new__ÚlitÚis_Not)Úclsr   r    Úobj©Ú	__class__© úT/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/assumptions/cnf.pyr   &   s    

zLiteral.__new__c                 C   s   | j S ©N©r   ©Úselfr%   r%   r&   Úarg1   s    zLiteral.argc                 C   s2   t | jƒr|  |¡}n| j |¡}t| ƒ|| jƒS r'   )Úcallabler   ÚapplyÚtyper    )r*   Úexprr   r%   r%   r&   Úrcall5   s    
zLiteral.rcallc                 C   s   | j  }t| j|ƒS r'   )r    r   r   )r*   r    r%   r%   r&   Ú
__invert__<   s    zLiteral.__invert__c                 C   s   d  t| ƒj| j| j¡S )Nz
{}({}, {}))Úformatr.   Ú__name__r   r    r)   r%   r%   r&   Ú__str__@   s    zLiteral.__str__c                 C   s   | j |j ko| j|jkS r'   )r+   r    ©r*   Úotherr%   r%   r&   Ú__eq__E   s    zLiteral.__eq__c                 C   s   t t| ƒj| j| jfƒ}|S r'   )Úhashr.   r3   r+   r    )r*   Úhr%   r%   r&   Ú__hash__H   s    zLiteral.__hash__)F)r3   Ú
__module__Ú__qualname__Ú__doc__r   Úpropertyr+   r0   r1   r4   Ú__repr__r7   r:   Ú__classcell__r%   r%   r#   r&   r      s   
r   c                   @   sP   e Zd ZdZdd„ Zedd„ ƒZdd„ Zdd	„ Zd
d„ Z	dd„ Z
dd„ ZeZdS )r   z+
    A low-level implementation for Or
    c                 G   s
   || _ d S r'   ©Ú_args©r*   r   r%   r%   r&   Ú__init__Q   s    zOR.__init__c                 C   s   t | jtd�S ©N)Úkey©ÚsortedrB   Ústrr)   r%   r%   r&   r   T   s    zOR.argsc                    s   t | ƒ‡ fdd„| jD ƒŽ S )Nc                    s   g | ]}|  ˆ ¡‘qS r%   ©r0   ©Ú.0r+   ©r/   r%   r&   Ú
<listcomp>Y   s   ÿzOR.rcall.<locals>.<listcomp>©r.   rB   ©r*   r/   r%   rM   r&   r0   X   s    ÿzOR.rcallc                 C   s   t dd„ | jD ƒŽ S )Nc                 S   s   g | ]
}| ‘qS r%   r%   rK   r%   r%   r&   rN   ^   s     z!OR.__invert__.<locals>.<listcomp>)r   rB   r)   r%   r%   r&   r1   ]   s    zOR.__invert__c                 C   s   t t| ƒjft| jƒ ƒS r'   ©r8   r.   r3   Útupler   r)   r%   r%   r&   r:   `   s    zOR.__hash__c                 C   s   | j |j kS r'   ©r   r5   r%   r%   r&   r7   c   s    z	OR.__eq__c                 C   s"   dd  dd„ | jD ƒ¡ d }|S )Nú(ú | c                 S   s   g | ]}t |ƒ‘qS r%   ©rI   rK   r%   r%   r&   rN   g   s     zOR.__str__.<locals>.<listcomp>ú)©Újoinr   ©r*   Úsr%   r%   r&   r4   f   s    z
OR.__str__N)r3   r;   r<   r=   rD   r>   r   r0   r1   r:   r7   r4   r?   r%   r%   r%   r&   r   M   s   
r   c                   @   sP   e Zd ZdZdd„ Zdd„ Zedd„ ƒZdd	„ Zd
d„ Z	dd„ Z
dd„ ZeZdS )r   z,
    A low-level implementation for And
    c                 G   s
   || _ d S r'   rA   rC   r%   r%   r&   rD   q   s    zAND.__init__c                 C   s   t dd„ | jD ƒŽ S )Nc                 S   s   g | ]
}| ‘qS r%   r%   rK   r%   r%   r&   rN   u   s     z"AND.__invert__.<locals>.<listcomp>)r   rB   r)   r%   r%   r&   r1   t   s    zAND.__invert__c                 C   s   t | jtd�S rE   rG   r)   r%   r%   r&   r   w   s    zAND.argsc                    s   t | ƒ‡ fdd„| jD ƒŽ S )Nc                    s   g | ]}|  ˆ ¡‘qS r%   rJ   rK   rM   r%   r&   rN   |   s   ÿzAND.rcall.<locals>.<listcomp>rO   rP   r%   rM   r&   r0   {   s    ÿz	AND.rcallc                 C   s   t t| ƒjft| jƒ ƒS r'   rQ   r)   r%   r%   r&   r:   €   s    zAND.__hash__c                 C   s   | j |j kS r'   rS   r5   r%   r%   r&   r7   ƒ   s    z
AND.__eq__c                 C   s"   dd  dd„ | jD ƒ¡ d }|S )NrT   ú & c                 S   s   g | ]}t |ƒ‘qS r%   rV   rK   r%   r%   r&   rN   ‡   s     zAND.__str__.<locals>.<listcomp>rW   rX   rZ   r%   r%   r&   r4   †   s    zAND.__str__N)r3   r;   r<   r=   rD   r1   r>   r   r0   r:   r7   r4   r?   r%   r%   r%   r&   r   m   s   
r   Nc                    sn  ddl m} ˆ dkri ‰ t|jt|jt|jt|j	t
|jt|ji}t| ƒ|krb|t| ƒ }|| jŽ } t| tƒr†| jd }t|ˆ ƒ}| S t| tƒr¬t‡ fdd„t | ¡D ƒŽ S t| tƒrÒt‡ fdd„t | ¡D ƒŽ S t| tƒrút‡ fdd„| jD ƒŽ }| S t| tƒ�r$t‡ fdd„| jD ƒŽ }| S t| tƒ�r’g }tdt| jƒd	 d
ƒD ]>}t| j|ƒD ]*‰‡ ‡fdd„| jD ƒ}	| t|	Ž ¡ �qZ�qJt|Ž S t| tƒ�rg }tdt| jƒd	 d
ƒD ]>}t| j|ƒD ]*‰‡ ‡fdd„| jD ƒ}	| t|	Ž ¡ �qÈ�q¸t|Ž  S t| t ƒ�r<t| jd ˆ ƒt| jd	 ˆ ƒ }
}t|
 |ƒS t| t!ƒ�r¦g }t"| j| jd	d… | jd d�D ]0\}}t|ˆ ƒ}t|ˆ ƒ}| t| |ƒ¡ �qlt|Ž S t| t#ƒ�rút| jd ˆ ƒ}
t| jd	 ˆ ƒ}t| jd
 ˆ ƒ}tt|
 |ƒt|
|ƒƒS t| t$ƒ�r:| j%| j& }}ˆ  '|d¡}|dk	�r:t|j(|Ž ˆ ƒS t| t)ƒ�rfˆ  '| d¡}|dk	�rft|ˆ ƒS t*| ƒ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                    s   g | ]}t |ˆ ƒ‘qS r%   ©Úto_NNF©rL   Úx©Úcomposite_mapr%   r&   rN   »   s     zto_NNF.<locals>.<listcomp>c                    s   g | ]}t |ˆ ƒ‘qS r%   r^   r`   rb   r%   r&   rN   ¾   s     c                    s   g | ]}t |ˆ ƒ‘qS r%   r^   r`   rb   r%   r&   rN   Á   s     c                    s   g | ]}t |ˆ ƒ‘qS r%   r^   r`   rb   r%   r&   rN   Å   s     é   é   c                    s*   g | ]"}|ˆkrt |ˆ ƒ nt |ˆ ƒ‘qS r%   r^   ©rL   r[   ©rc   Únegr%   r&   rN   Ì   s   ÿc                    s*   g | ]"}|ˆkrt |ˆ ƒ nt |ˆ ƒ‘qS r%   r^   rf   rg   r%   r&   rN   Õ   s   ÿ)Ú	fillvalue)+Zsympy.assumptions.askr]   r   Úeqr   Úner	   Úgtr
   Últr   Úger   Úler.   r   r   r   r_   r   r   Z	make_argsr   r   r   r   r   ÚrangeÚlenr   Úappendr   r   r   r   r   r   ÚfunctionÚ	argumentsÚgetr0   r   r   )r/   rc   r]   ZbinrelpredsÚpredr+   ÚtmpÚcnfsÚiÚclauseÚLÚRÚaÚbÚMr   Znewpredr%   rg   r&   r_   �   s€    (






ÿÿ
"(




r_   c                 C   sp   t | ttfƒs,tƒ }| t| fƒ¡ t|ƒS t | tƒrLtjdd„ | jD ƒŽ S t | tƒrltj	d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                 S   s   g | ]}t |ƒ‘qS r%   ©Údistribute_AND_over_ORrK   r%   r%   r&   rN     s   ÿz*distribute_AND_over_OR.<locals>.<listcomp>c                 S   s   g | ]}t |ƒ‘qS r%   r€   rK   r%   r%   r&   rN   
  s   ÿN)
r   r   r   ÚsetÚaddÚ	frozensetÚCNFÚall_orrB   Úall_and)r/   rw   r%   r%   r&   r�   ú   s    

ÿ

ÿr�   c                   @   s®   e Zd ZdZd%dd„Zdd„ Zdd„ Zd	d
„ Zdd„ Zdd„ Z	e
dd„ ƒZdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Ze
dd„ ƒZe
dd „ ƒZe
d!d"„ ƒZe
d#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                 C   s   |s
t ƒ }|| _d S r'   ©r‚   Úclauses©r*   r‰   r%   r%   r&   rD      s    zCNF.__init__c                 C   s   t  |¡j}|  |¡ d S r'   )r…   Úto_CNFr‰   Úadd_clauses)r*   Úpropr‰   r%   r%   r&   rƒ   %  s    zCNF.addc                 C   s   d  dd„ | jD ƒ¡}|S )Nr\   c                 S   s(   g | ] }d d  dd„ |D ƒ¡ d ‘qS )rT   rU   c                 S   s   g | ]}t |ƒ‘qS r%   rV   )rL   r   r%   r%   r&   rN   +  s     z*CNF.__str__.<locals>.<listcomp>.<listcomp>rW   )rY   ©rL   rz   r%   r%   r&   rN   +  s   ÿzCNF.__str__.<locals>.<listcomp>)rY   r‰   rZ   r%   r%   r&   r4   )  s    ÿÿzCNF.__str__c                 C   s   |D ]}|   |¡ q| S r'   ©rƒ   )r*   ÚpropsÚpr%   r%   r&   Úextend0  s    z
CNF.extendc                 C   s   t t| jƒƒS r'   )r…   r‚   r‰   r)   r%   r%   r&   Úcopy5  s    zCNF.copyc                 C   s   |  j |O  _ d S r'   )r‰   rŠ   r%   r%   r&   rŒ   8  s    zCNF.add_clausesc                 C   s   | ƒ }|  |¡ |S r'   r�   )r!   r�   Úresr%   r%   r&   Ú	from_prop;  s    
zCNF.from_propc                 C   s   |   |j¡ | S r'   )rŒ   r‰   r5   r%   r%   r&   Ú__iand__A  s    zCNF.__iand__c                 C   s(   t ƒ }| jD ]}|dd„ |D ƒO }q|S )Nc                 S   s   h | ]
}|j ’qS r%   r(   rK   r%   r%   r&   Ú	<setcomp>H  s     z%CNF.all_predicates.<locals>.<setcomp>rˆ   )r*   Z
predicatesÚcr%   r%   r&   Úall_predicatesE  s    
zCNF.all_predicatesc                 C   sF   t ƒ }t| j|jƒD ](\}}t |ƒ}| |¡ | t|ƒ¡ qt|ƒS r'   )r‚   r   r‰   Úupdaterƒ   r„   r…   )r*   Úcnfr‰   r}   r~   rw   r%   r%   r&   Ú_orK  s    
zCNF._orc                 C   s   | j  |j ¡}t|ƒS r'   )r‰   Úunionr…   ©r*   r›   r‰   r%   r%   r&   Ú_andS  s    zCNF._andc                 C   sV   t | jƒ}dd„ |d D ƒ}t|ƒ}|d d… D ] }dd„ |D ƒ}| t|ƒ¡}q0|S )Nc                 S   s   h | ]}t | fƒ’qS r%   ©r„   r`   r%   r%   r&   r—   Y  s     zCNF._not.<locals>.<setcomp>éÿÿÿÿc                 S   s   h | ]}t | fƒ’qS r%   r    r`   r%   r%   r&   r—   ]  s     )Úlistr‰   r…   rœ   )r*   ZclssZllÚrestr‘   r%   r%   r&   Ú_notW  s    
zCNF._notc                    s@   g }| j D ]$}‡ fdd„|D ƒ}| t|Ž ¡ q
t|Ž ‰ tˆ ƒS )Nc                    s   g | ]}|  ˆ ¡‘qS r%   rJ   rK   rM   r%   r&   rN   d  s     zCNF.rcall.<locals>.<listcomp>)r‰   rr   r   r   r�   )r*   r/   Zclause_listrz   Zlitsr%   rM   r&   r0   a  s    
z	CNF.rcallc                 G   s,   |d   ¡ }|dd … D ]}| |¡}q|S ©Nr   rd   )r“   rœ   ©r!   rx   r~   r£   r%   r%   r&   r†   i  s    z
CNF.all_orc                 G   s,   |d   ¡ }|dd … D ]}| |¡}q|S r¥   )r“   rŸ   r¦   r%   r%   r&   r‡   p  s    zCNF.all_andc                 C   s$   ddl m} t||ƒ ƒ}t|ƒ}|S )Nr   )Úget_composite_predicates)Zsympy.assumptions.factsr§   r_   r�   )r!   r/   r§   r%   r%   r&   r‹   w  s    z
CNF.to_CNFc                    s    dd„ ‰ t ‡ fdd„|jD ƒŽ S )zm
        Converts CNF object to SymPy's boolean expression
        retaining the form of expression.
        c                 S   s   | j rt| jƒS | jS r'   )r    r   r   )r+   r%   r%   r&   Úremove_literal„  s    z&CNF.CNF_to_cnf.<locals>.remove_literalc                 3   s$   | ]}t ‡ fd d„|D ƒŽ V  qdS )c                 3   s   | ]}ˆ |ƒV  qd S r'   r%   rK   ©r¨   r%   r&   Ú	<genexpr>‡  s     z+CNF.CNF_to_cnf.<locals>.<genexpr>.<genexpr>N)r   rŽ   r©   r%   r&   rª   ‡  s     z!CNF.CNF_to_cnf.<locals>.<genexpr>)r   r‰   )r!   r›   r%   r©   r&   Ú
CNF_to_cnf~  s    zCNF.CNF_to_cnf)N)r3   r;   r<   r=   rD   rƒ   r4   r’   r“   rŒ   Úclassmethodr•   r–   r™   rœ   rŸ   r¤   r0   r†   r‡   r‹   r«   r%   r%   r%   r&   r…     s.   





r…   c                   @   sb   e Zd ZdZddd„Zdd„ Zedd„ ƒZed	d
„ ƒZdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ ZdS )Ú
EncodedCNFz0
    Class for encoding the CNF expression.
    Nc                 C   s.   |s|sg }i }|| _ || _t| ¡ ƒ| _d S r'   )ÚdataÚencodingr¢   ÚkeysÚ_symbols)r*   r®   r¯   r%   r%   r&   rD   Ž  s    zEncodedCNF.__init__c                    sN   t | ¡ ƒˆ _tˆ jƒ}ttˆ jtd|d ƒƒƒˆ _‡ fdd„|jD ƒˆ _	d S )Nrd   c                    s   g | ]}ˆ   |¡‘qS r%   ©ÚencoderŽ   r)   r%   r&   rN   š  s     z'EncodedCNF.from_cnf.<locals>.<listcomp>)
r¢   r™   r±   rq   ÚdictÚziprp   r¯   r‰   r®   )r*   r›   Únr%   r)   r&   Úfrom_cnf–  s    
zEncodedCNF.from_cnfc                 C   s   | j S r'   )r±   r)   r%   r%   r&   Úsymbolsœ  s    zEncodedCNF.symbolsc                 C   s   t dt| jƒd ƒS ©Nrd   )rp   rq   r±   r)   r%   r%   r&   Ú	variables   s    zEncodedCNF.variablesc                 C   s    dd„ | j D ƒ}t|t| jƒƒS )Nc                 S   s   g | ]}t |ƒ‘qS r%   )r‚   rŽ   r%   r%   r&   rN   ¥  s     z#EncodedCNF.copy.<locals>.<listcomp>)r®   r­   r´   r¯   )r*   Znew_datar%   r%   r&   r“   ¤  s    zEncodedCNF.copyc                 C   s   t  |¡}|  |¡ d S r'   )r…   r•   Úadd_from_cnf)r*   r�   r›   r%   r%   r&   Úadd_prop¨  s    
zEncodedCNF.add_propc                    s&   ‡ fdd„|j D ƒ}ˆ  j|7  _d S )Nc                    s   g | ]}ˆ   |¡‘qS r%   r²   rŽ   r)   r%   r&   rN   ­  s     z+EncodedCNF.add_from_cnf.<locals>.<listcomp>)r‰   r®   rž   r%   r)   r&   r»   ¬  s    zEncodedCNF.add_from_cnfc                 C   sX   |j }| j |d ¡}|d krDt| jƒ}| j |¡ |d  }| j|< |jrP| S |S d S r¹   )r   r¯   ru   rq   r±   rr   r    )r*   r+   ÚliteralÚvaluer¶   r%   r%   r&   Ú
encode_arg°  s    
zEncodedCNF.encode_argc                    s   ‡ fdd„|D ƒS )Nc                    s&   h | ]}|j tjksˆ  |¡nd ’qS )r   )r   r   Úfalser¿   rK   r)   r%   r&   r—   ½  s     z$EncodedCNF.encode.<locals>.<setcomp>r%   )r*   rz   r%   r)   r&   r³   ¼  s    zEncodedCNF.encode)NN)r3   r;   r<   r=   rD   r·   r>   r¸   rº   r“   r¼   r»   r¿   r³   r%   r%   r%   r&   r­   Š  s   


r­   )N)#r=   Ú	itertoolsr   r   r   Zsympy.assumptions.assumer   r   Zsympy.core.relationalr   r   r	   r
   r   r   Zsympy.core.singletonr   Zsympy.logic.boolalgr   r   r   r   r   r   r   r   r   r   r   r   r   r_   r�   r…   r­   r%   r%   r%   r&   Ú<module>   s     >  
m|