o
    jg0                     @   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__ M/var/www/html/zoom/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rt fdd| jD  }| S t| trg }tdt| jd	 d
D ]}t| j|D ] fdd| jD }	|t|	  qqt| S t| trg }tdt| jd	 d
D ]}t| j|D ] fdd| jD }	|t|	  qqt|  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rt|j(|  S t| t)r '| d}|durt| 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   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+   clss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   clause_listr   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)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+   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   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|