B
    cd1                 @   s   d Z ddlmZmZ ddlmZ ddlmZmZm	Z	m
Z
mZmZ ddlmZmZmZmZmZmZ ddlmZmZmZmZ ddl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)S)
EquivalentITEImpliesNandNorXor)EqNeGtLtGeLe)OrAndNotXnor)zip_longestc                   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__ b/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/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   sX   t | jr| |}n2y| j|}W n  tk
rF   | j|}Y nX t| || jS )N)callabler   applyAttributeErrorrcalltyper   )r$   exprr   r"   r"   r#   r)   5   s    
zLiteral.rcallc             C   s   | j  }t| j|S )N)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__C   s    zLiteral.__str__c             C   s   | j |j ko| j|jkS )N)r%   r   )r$   otherr"   r"   r#   __eq__H   s    zLiteral.__eq__c             C   s   t t| j| j| jf}|S )N)hashr*   r.   r%   r   )r$   hr"   r"   r#   __hash__K   s    zLiteral.__hash__)F)r.   
__module____qualname____doc__r   propertyr%   r)   r,   r/   __repr__r1   r4   __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 )N)_args)r$   r   r"   r"   r#   __init__T   s    zOR.__init__c             C   s   t | jtdS )N)key)sortedr;   str)r$   r"   r"   r#   r   W   s    zOR.argsc                s   t |  fdd| jD  S )Nc                s   g | ]}|  qS r"   )r)   ).0r%   )r+   r"   r#   
<listcomp>\   s   zOR.rcall.<locals>.<listcomp>)r*   r;   )r$   r+   r"   )r+   r#   r)   [   s    zOR.rcallc             C   s   t dd | jD  S )Nc             S   s   g | ]
}| qS r"   r"   )r@   r%   r"   r"   r#   rA   a   s    z!OR.__invert__.<locals>.<listcomp>)r   r;   )r$   r"   r"   r#   r,   `   s    zOR.__invert__c             C   s   t t| jft| j S )N)r2   r*   r.   tupler   )r$   r"   r"   r#   r4   c   s    zOR.__hash__c             C   s   | j |j kS )N)r   )r$   r0   r"   r"   r#   r1   f   s    z	OR.__eq__c             C   s"   dd dd | jD  d }|S )N(z | c             S   s   g | ]}t |qS r"   )r?   )r@   r%   r"   r"   r#   rA   j   s    zOR.__str__.<locals>.<listcomp>))joinr   )r$   sr"   r"   r#   r/   i   s    z
OR.__str__N)r.   r5   r6   r7   r<   r8   r   r)   r,   r4   r1   r/   r9   r"   r"   r"   r#   r   P   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 )N)r;   )r$   r   r"   r"   r#   r<   t   s    zAND.__init__c             C   s   t dd | jD  S )Nc             S   s   g | ]
}| qS r"   r"   )r@   r%   r"   r"   r#   rA   x   s    z"AND.__invert__.<locals>.<listcomp>)r   r;   )r$   r"   r"   r#   r,   w   s    zAND.__invert__c             C   s   t | jtdS )N)r=   )r>   r;   r?   )r$   r"   r"   r#   r   z   s    zAND.argsc                s   t |  fdd| jD  S )Nc                s   g | ]}|  qS r"   )r)   )r@   r%   )r+   r"   r#   rA      s   zAND.rcall.<locals>.<listcomp>)r*   r;   )r$   r+   r"   )r+   r#   r)   ~   s    z	AND.rcallc             C   s   t t| jft| j S )N)r2   r*   r.   rB   r   )r$   r"   r"   r#   r4      s    zAND.__hash__c             C   s   | j |j kS )N)r   )r$   r0   r"   r"   r#   r1      s    z
AND.__eq__c             C   s"   dd dd | jD  d }|S )NrC   z & c             S   s   g | ]}t |qS r"   )r?   )r@   r%   r"   r"   r#   rA      s    zAND.__str__.<locals>.<listcomp>rD   )rE   r   )r$   rF   r"   r"   r#   r/      s    zAND.__str__N)r.   r5   r6   r7   r<   r,   r8   r   r)   r4   r1   r/   r9   r"   r"   r"   r#   r   p   s   r   Nc                s  ddl m} ddlm}m}  dkr*t  t|jt|j	t
|jt|jt|jt|ji}t| |krt|t|  }|| j } t| tr| jd }t| }| S t| trt fddt| D  S t| trt fddt| D  S t| trt fdd| jD  }| S t| tr8t fd	d| jD  }| S t| trg }	x\tdt | jd
 dD ]B}
x:t!| j|
D ]* fdd| jD }|	"t|  qrW q`W t|	 S t| t#r&g }	x\tdt | jd
 dD ]B}
x:t!| j|
D ]* fdd| jD }|	"t|  qW qW t|	  S t| t$r`t| jd  t| jd
   }}t| |S t| t%rg }	xTt&| j| jd
d | jd dD ]0\}}t| }t| }|	"t| | qW t|	 S t| t'r"t| jd  }t| jd
  }t| jd  }tt| |t||S t| |rb| j(| j) }} *|d}|dk	rbt|j+|  S t| |r *| d}|dk	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   )Q)AppliedPredicate	PredicateNc                s   g | ]}t | qS r"   )to_NNF)r@   x)composite_mapr"   r#   rA      s    zto_NNF.<locals>.<listcomp>c                s   g | ]}t | qS r"   )rJ   )r@   rK   )rL   r"   r#   rA      s    c                s   g | ]}t | qS r"   )rJ   )r@   rK   )rL   r"   r#   rA      s    c                s   g | ]}t | qS r"   )rJ   )r@   rK   )rL   r"   r#   rA      s          c                s*   g | ]"}|krt |  nt | qS r"   )rJ   )r@   rF   )rL   negr"   r#   rA      s   c                s*   g | ]"}|krt |  nt | qS r"   )rJ   )r@   rF   )rL   rO   r"   r#   rA      s   )	fillvalue)-Zsympy.assumptions.askrG   Zsympy.assumptions.assumerH   rI   dictr   eqr   ner   gtr   ltr   ger   ler*   r   r   r   rJ   r   r   Z	make_argsr   r   r   r	   r
   rangelenr   appendr   r   r   r   r   function	argumentsgetr)   r   )r+   rL   rG   rH   rI   Zbinrelpredspredr%   tmpcnfsiclauseLRabMr   Znewpredr"   )rL   rO   r#   rJ      s~    (








"*




rJ   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_OR)r@   r%   r"   r"   r#   rA   
  s   z*distribute_AND_over_OR.<locals>.<listcomp>c             S   s   g | ]}t |qS r"   )rh   )r@   r%   r"   r"   r#   rA     s   N)
r   r   r   setadd	frozensetCNFall_orr;   all_and)r+   r_   r"   r"   r#   rh      s    



rh   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 )&rl   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 )N)ri   clauses)r$   ro   r"   r"   r#   r<   $  s    zCNF.__init__c             C   s   t |j}| | d S )N)rl   to_CNFro   add_clauses)r$   propro   r"   r"   r#   rj   )  s    zCNF.addc             C   s   d dd | jD }|S )Nz & c             S   s(   g | ] }d d dd |D  d qS )rC   z | c             S   s   g | ]}t |qS r"   )r?   )r@   r   r"   r"   r#   rA   /  s    z*CNF.__str__.<locals>.<listcomp>.<listcomp>rD   )rE   )r@   rb   r"   r"   r#   rA   /  s   zCNF.__str__.<locals>.<listcomp>)rE   ro   )r$   rF   r"   r"   r#   r/   -  s    zCNF.__str__c             C   s   x|D ]}|  | qW | S )N)rj   )r$   propspr"   r"   r#   extend4  s    
z
CNF.extendc             C   s   t t| jS )N)rl   ri   ro   )r$   r"   r"   r#   copy9  s    zCNF.copyc             C   s   |  j |O  _ d S )N)ro   )r$   ro   r"   r"   r#   rq   <  s    zCNF.add_clausesc             C   s   |  }| | |S )N)rj   )r   rr   resr"   r"   r#   	from_prop?  s    
zCNF.from_propc             C   s   |  |j | S )N)rq   ro   )r$   r0   r"   r"   r#   __iand__E  s    zCNF.__iand__c             C   s,   t  }x | jD ]}|dd |D O }qW |S )Nc             S   s   h | ]
}|j qS r"   )r   )r@   r%   r"   r"   r#   	<setcomp>L  s    z%CNF.all_predicates.<locals>.<setcomp>)ri   ro   )r$   Z
predicatescr"   r"   r#   all_predicatesI  s    zCNF.all_predicatesc             C   sX   t  }xHt| j|jD ]6\}}t |}x|D ]}|| q,W |t| qW t|S )N)ri   r   ro   rj   rk   rl   )r$   cnfro   re   rf   r_   tr"   r"   r#   _orO  s    
zCNF._orc             C   s   | j |j }t|S )N)ro   unionrl   )r$   r}   ro   r"   r"   r#   _andX  s    zCNF._andc             C   s   t | j}t }x"|d D ]}|t| f qW t|}xH|d d D ]8}t }x|D ]}|t| f qZW |t|}qJW |S )N)listro   ri   rj   rk   rl   r   )r$   ZclssllrK   restrt   r"   r"   r#   _not\  s    

zCNF._notc                sF   t  }x.| jD ]$} fdd|D }|t|  qW t|  t S )Nc                s   g | ]}|  qS r"   )r)   )r@   r%   )r+   r"   r#   rA   m  s    zCNF.rcall.<locals>.<listcomp>)r   ro   rZ   r   r   rh   )r$   r+   Zclause_listrb   Zlitsr"   )r+   r#   r)   j  s    z	CNF.rcallc             G   s0   |d   }x|dd  D ]}||}qW |S )Nr   rM   )rv   r   )r   r`   rf   r   r"   r"   r#   rm   r  s    z
CNF.all_orc             G   s0   |d   }x|dd  D ]}||}qW |S )Nr   rM   )rv   r   )r   r`   rf   r   r"   r"   r#   rn   y  s    zCNF.all_andc             C   s$   ddl m} t|| }t|}|S )Nr   )get_composite_predicates)Zsympy.assumptions.factsr   rJ   rh   )r   r+   r   r"   r"   r#   rp     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 )N)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 )Nr"   )r@   r%   )r   r"   r#   	<genexpr>  s    z+CNF.CNF_to_cnf.<locals>.<genexpr>.<genexpr>N)r   )r@   rb   )r   r"   r#   r     s    z!CNF.CNF_to_cnf.<locals>.<genexpr>)r   ro   )r   r}   r"   )r   r#   
CNF_to_cnf  s    zCNF.CNF_to_cnf)N)r.   r5   r6   r7   r<   rj   r/   ru   rv   rq   classmethodrx   ry   r|   r   r   r   r)   rm   rn   rp   r   r"   r"   r"   r#   rl     s$   
	rl   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   s2   |s|st  }t }|| _|| _t | | _d S )N)r   rQ   dataencodingkeys_symbols)r$   r   r   r"   r"   r#   r<     s    zEncodedCNF.__init__c          	      sV   t |  _t j}tt t jt td|d  _ fdd|jD  _	d S )NrM   c                s   g | ]}  |qS r"   )encode)r@   rb   )r$   r"   r#   rA     s    z'EncodedCNF.from_cnf.<locals>.<listcomp>)
r   r|   r   rY   rQ   ziprX   r   ro   r   )r$   r}   nr"   )r$   r#   from_cnf  s    
$zEncodedCNF.from_cnfc             C   s   | j S )N)r   )r$   r"   r"   r#   symbols  s    zEncodedCNF.symbolsc             C   s   t dt| jd S )NrM   )rX   rY   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"   )ri   )r@   rb   r"   r"   r#   rA     s    z#EncodedCNF.copy.<locals>.<listcomp>)r   r   rQ   r   )r$   Znew_datar"   r"   r#   rv     s    zEncodedCNF.copyc             C   s   t |}| | d S )N)rl   rx   add_from_cnf)r$   rr   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@   rb   )r$   r"   r#   rA     s    z+EncodedCNF.add_from_cnf.<locals>.<listcomp>)ro   r   )r$   r}   ro   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 )NrM   )r   r   r]   rY   r   rZ   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   )r@   r%   )r$   r"   r#   rz     s    z$EncodedCNF.encode.<locals>.<setcomp>r"   )r$   rb   r"   )r$   r#   r     s    zEncodedCNF.encode)NN)r.   r5   r6   r7   r<   r   r8   r   r   rv   r   r   r   r   r"   r"   r"   r#   r     s   
r   )N) r7   	itertoolsr   r   Zsympy.core.singletonr   Zsympy.logic.boolalgr   r   r   r   r	   r
   Zsympy.core.relationalr   r   r   r   r   r   r   r   r   r   r   r   r   r   rJ   rh   rl   r   r"   r"   r"   r#   <module>   s     A  
n 