o
    "ô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ƒr|r| S |S tƒ  | ¡}||_||_	|S )Nr   T)
Ú
isinstancer   ÚargsÚANDÚORr   ÚsuperÚ__new__ÚlitÚis_Not)Úclsr   r    Úobj©Ú	__class__© úh/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/sympy/assumptions/cnf.pyr   &   s   

zLiteral.__new__c                 C   ó   | j S ©N©r   ©Úselfr%   r%   r&   Úarg1   ó   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
{}({}, {}))Úformatr0   Ú__name__r   r    r*   r%   r%   r&   Ú__str__@   ó   zLiteral.__str__c                 C   s   | j |j ko| j|jkS r(   )r,   r    ©r+   Úotherr%   r%   r&   Ú__eq__E   r7   zLiteral.__eq__c                 C   s   t t| ƒj| j| jfƒ}|S r(   )Úhashr0   r5   r,   r    )r+   Úhr%   r%   r&   Ú__hash__H   s   zLiteral.__hash__)F)r5   Ú
__module__Ú__qualname__Ú__doc__r   Úpropertyr,   r2   r3   r6   Ú__repr__r:   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   ó
   || _ d S r(   ©Ú_args©r+   r   r%   r%   r&   Ú__init__Q   ó   
zOR.__init__c                 C   ó   t | jtd�S ©N)Úkey©ÚsortedrF   Ústrr*   r%   r%   r&   r   T   ó   zOR.argsc                    ó   t | ƒ‡ fdd„| jD ƒŽ S )Nc                    ó   g | ]}|  ˆ ¡‘qS r%   ©r2   ©Ú.0r,   ©r1   r%   r&   Ú
<listcomp>Y   ó    ÿzOR.rcall.<locals>.<listcomp>©r0   rF   ©r+   r1   r%   rV   r&   r2   X   ó   ÿzOR.rcallc                 C   ó   t dd„ | jD ƒŽ S )Nc                 S   ó   g | ]}| ‘qS r%   r%   rT   r%   r%   r&   rW   ^   ó    z!OR.__invert__.<locals>.<listcomp>)r   rF   r*   r%   r%   r&   r3   ]   ó   zOR.__invert__c                 C   ó   t t| ƒjft| jƒ ƒS r(   ©r;   r0   r5   Útupler   r*   r%   r%   r&   r=   `   ó   zOR.__hash__c                 C   ó   | j |j kS r(   ©r   r8   r%   r%   r&   r:   c   ó   z	OR.__eq__c                 C   ó"   dd  dd„ | jD ƒ¡ d }|S )Nú(ú | c                 S   ó   g | ]}t |ƒ‘qS r%   ©rO   rT   r%   r%   r&   rW   g   ó    zOR.__str__.<locals>.<listcomp>ú)©Újoinr   ©r+   Úsr%   r%   r&   r6   f   ó   z
OR.__str__N)r5   r>   r?   r@   rH   rA   r   r2   r3   r=   r:   r6   rB   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   rD   r(   rE   rG   r%   r%   r&   rH   q   rI   zAND.__init__c                 C   r\   )Nc                 S   r]   r%   r%   rT   r%   r%   r&   rW   u   r^   z"AND.__invert__.<locals>.<listcomp>)r   rF   r*   r%   r%   r&   r3   t   r_   zAND.__invert__c                 C   rJ   rK   rM   r*   r%   r%   r&   r   w   rP   zAND.argsc                    rQ   )Nc                    rR   r%   rS   rT   rV   r%   r&   rW   |   rX   zAND.rcall.<locals>.<listcomp>rY   rZ   r%   rV   r&   r2   {   r[   z	AND.rcallc                 C   r`   r(   ra   r*   r%   r%   r&   r=   €   rc   zAND.__hash__c                 C   rd   r(   re   r8   r%   r%   r&   r:   ƒ   rf   z
AND.__eq__c                 C   rg   )Nrh   ú & c                 S   rj   r%   rk   rT   r%   r%   r&   rW   ‡   rl   zAND.__str__.<locals>.<listcomp>rm   rn   rp   r%   r%   r&   r6   †   rr   zAND.__str__N)r5   r>   r?   r@   rH   r3   rA   r   r2   r=   r:   r6   rB   r%   r%   r%   r&   r   m   s    
r   Nc                    s`  ddl m} ˆ du ri ‰ t|jt|jt|jt|j	t
|jt|ji}t| ƒ|v r1|t| ƒ }|| jŽ } t| tƒrC| jd }t|ˆ ƒ}| S t| tƒrVt‡ fdd„t | ¡D ƒŽ S t| tƒrit‡ 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|	Ž ¡ q«q£t|Ž 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!ƒ�rLg }t"| j| jd	d… | jd d�D ]\}}t|ˆ ƒ}t|ˆ ƒ}| t| |ƒ¡ �q/t|Ž S t| t#ƒ�rvt| jd ˆ ƒ}
t| jd	 ˆ ƒ}t| jd
 ˆ ƒ}tt|
 |ƒt|
|ƒƒS t| t$ƒ�r–| j%| j&}}ˆ  '|d¡}|du�r–t|j(|Ž ˆ ƒS t| t)ƒ�r¬ˆ  '| d¡}|du�r¬t|ˆ ƒ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                    ó   g | ]}t |ˆ ƒ‘qS r%   ©Úto_NNF©rU   Úx©Úcomposite_mapr%   r&   rW   »   ó    zto_NNF.<locals>.<listcomp>c                    ru   r%   rv   rx   rz   r%   r&   rW   ¾   r|   c                    ru   r%   rv   rx   rz   r%   r&   rW   Á   r|   c                    ru   r%   rv   rx   rz   r%   r&   rW   Å   r|   é   é   c                    ó*   g | ]}|ˆv rt |ˆ ƒ nt |ˆ ƒ‘qS r%   rv   ©rU   rq   ©r{   Únegr%   r&   rW   Ì   ó    "ÿc                    r   r%   rv   r€   r�   r%   r&   rW   Õ   rƒ   )Ú	fillvalue)+Úsympy.assumptions.askrt   r   Úeqr   Úner	   Úgtr
   Últr   Úger   Úler0   r   r   r   rw   r   r   Ú	make_argsr   r   r   r   r   ÚrangeÚlenr   Úappendr   r   r   r   r   r   ÚfunctionÚ	argumentsÚgetr2   r   r   )r1   r{   rt   ÚbinrelpredsÚpredr,   ÚtmpÚcnfsÚiÚclauseÚLÚRÚaÚbÚMr   Znewpredr%   r�   r&   rw   �   s„   (








ÿý
ÿý
"(




rw   c                 C   sp   t | ttfƒstƒ }| t| fƒ¡ t|ƒS t | tƒr&tjdd„ | jD ƒŽ S t | tƒr6t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   rj   r%   ©Údistribute_AND_over_ORrT   r%   r%   r&   rW     ó    ÿz*distribute_AND_over_OR.<locals>.<listcomp>c                 S   rj   r%   rž   rT   r%   r%   r&   rW   
  r    N)
r   r   r   ÚsetÚaddÚ	frozensetÚCNFÚall_orrF   Úall_and)r1   r•   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&   rH      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 )Nrs   c                 S   s(   g | ]}d d  dd„ |D ƒ¡ d ‘qS )rh   ri   c                 S   rj   r%   rk   )rU   r   r%   r%   r&   rW   +  rl   z*CNF.__str__.<locals>.<listcomp>.<listcomp>rm   )ro   ©rU   r˜   r%   r%   r&   rW   +  s     ÿzCNF.__str__.<locals>.<listcomp>)ro   r¨   rp   r%   r%   r&   r6   )  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  ó   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¨   r8   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)   rT   r%   r%   r&   Ú	<setcomp>H  r^   z%CNF.all_predicates.<locals>.<setcomp>r§   )r+   Ú
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œ   r•   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|ƒ¡}q|S )Nc                 S   ó   h | ]}t | fƒ’qS r%   ©r£   rx   r%   r%   r&   r·   Y  ó    zCNF._not.<locals>.<setcomp>éÿÿÿÿc                 S   rÁ   r%   rÂ   rx   r%   r%   r&   r·   ]  rÃ   )Ú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                    rR   r%   rS   rT   rV   r%   r&   rW   d  r|   zCNF.rcall.<locals>.<listcomp>)r¨   r�   r   r   rŸ   )r+   r1   Zclause_listr˜   Zlitsr%   rV   r&   r2   a  s   
z	CNF.rcallc                 G   ó,   |d   ¡ }|dd … D ]}| |¡}q|S ©Nr   r}   )r²   r½   ©r!   r–   rœ   rÆ   r%   r%   r&   r¥   i  ó   z
CNF.all_orc                 G   rÈ   rÉ   )r²   rÀ   rÊ   r%   r%   r&   r¦   p  rË   zCNF.all_andc                 C   s$   ddl m} t||ƒ ƒ}t|ƒ}|S )Nr   )Úget_composite_predicates)Zsympy.assumptions.factsrÌ   rw   rŸ   )r!   r1   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%   rT   ©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_cnfr(   )r5   r>   r?   r@   rH   r¢   r6   r±   r²   r«   Úclassmethodrµ   r¶   rº   r½   rÀ   rÇ   r2   r¥   r¦   rª   rÐ   r%   r%   r%   r&   r¤     s0    





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&   rH   Ž  s   zEncodedCNF.__init__c                    sN   t | ¡ ƒˆ _tˆ jƒ}ttˆ jtd|d ƒƒƒˆ _‡ fdd„|jD ƒˆ _	d S )Nr}   c                    ó   g | ]}ˆ   |¡‘qS r%   ©Úencoder­   r*   r%   r&   rW   š  r|   z'EncodedCNF.from_cnf.<locals>.<listcomp>)
rÅ   rº   rÖ   rŽ   ÚdictÚzipr�   rÔ   r¨   rÓ   )r+   r¼   Únr%   r*   r&   Úfrom_cnf–  s   
zEncodedCNF.from_cnfc                 C   r'   r(   )rÖ   r*   r%   r%   r&   Úsymbolsœ  r-   zEncodedCNF.symbolsc                 C   s   t dt| jƒd ƒS ©Nr}   )r�   rŽ   rÖ   r*   r%   r%   r&   Ú	variables   s   zEncodedCNF.variablesc                 C   s    dd„ | j D ƒ}t|t| jƒƒS )Nc                 S   rj   r%   )r¡   r­   r%   r%   r&   rW   ¥  rl   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                    r×   r%   rØ   r­   r*   r%   r&   rW   ­  r|   z+EncodedCNF.add_from_cnf.<locals>.<listcomp>)r¨   rÓ   r¿   r%   r*   r&   rá   ¬  s   zEncodedCNF.add_from_cnfc                 C   sT   |j }| j |d ¡}|d u r"t| jƒ}| j |¡ |d  }| j|< |jr(| S |S rß   )r   rÔ   r’   rŽ   rÖ   r�   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å   rT   r*   r%   r&   r·   ½  s   & z$EncodedCNF.encode.<locals>.<setcomp>r%   )r+   r˜   r%   r*   r&   rÙ   ¼  r³   zEncodedCNF.encode)NN)r5   r>   r?   r@   rH   rÝ   rA   rÞ   rà   r²   râ   rá   rå   rÙ   r%   r%   r%   r&   rÒ   Š  s    


rÒ   r(   )#r@   Ú	itertoolsr   r   r   Úsympy.assumptions.assumer   r   Úsympy.core.relationalr   r   r	   r
   r   r   Zsympy.core.singletonr   Úsympy.logic.boolalgr   r   r   r   r   r   r   r   r   r   r   r   r   rw   rŸ   r¤   rÒ   r%   r%   r%   r&   Ú<module>   s      > 
 m|