U
    L?h[%  ã                   @   s.  d dl mZ d dlmZmZ d dlmZ d dlmZ d dl	m
Z
mZ d dlmZ d dlmZ d dl mZ d d	lmZ d d
lmZ defdd„Zeejejejejejejejejejejejej ej!hB Z"dd„ Z#dd„ Z$dd„ Z%ejejejejejejejejejejej dej!diZ&dd„ Z'dd„ Z(dS )é    )Úglobal_assumptions)ÚCNFÚ
EncodedCNF)ÚQ)Úsatisfiable)ÚUnhandledInputÚALLOWED_PRED)Ú
MatrixKind)Ú
NumberKind)ÚAppliedPredicate)ÚMul)ÚSTc                 C   sZ   t  | ¡}t  |  ¡}t  |¡}tƒ }| |¡ t ƒ }|rD| |¡}| |¡ t|||ƒS )aO  
    Function to evaluate the proposition with assumptions using SAT algorithm
    in conjunction with an Linear Real Arithmetic theory solver.

    Used to handle inequalities. Should eventually be depreciated and combined
    into satask, but infinity handling and other things need to be implemented
    before that can happen.
    )r   Z	from_propr   Zfrom_cnfÚextendÚadd_from_cnfÚcheck_satisfiability)ZpropositionZassumptionsÚcontextÚpropsZ_propsZcnfZcontext_cnf© r   úN/var/www/html/venv/lib/python3.8/site-packages/sympy/assumptions/lra_satask.pyÚ
lra_satask   s    	




r   c                 C   sŒ  |  ¡ }|  ¡ }| | ¡ | |¡ t|ƒ\}}|D ]*}|jtkr4|jtjkr4td|› dƒ‚q4|D ]4}|jt	t
ƒkr†td|› dƒ‚|tjkrdtdƒ‚qdt|ƒD ]p}	t|jƒ}
|	|jkrÈ|
d |j|	< |j |j|	 g¡ t|jƒ}
|	|jkrþ|
d |j|	< |j |j|	 g¡ q¢t|ƒ}t|ƒ}t|dddk	}t|dddk	}|rT|rTd S |rd|sddS |st|rtdS |sˆ|sˆtd	ƒ‚d S )
NúLRASolver: z is an unhandled predicatez is of MatrixKindzLRASolver: nané   T)Zuse_lra_theoryFzInconsistent assumptions)Úcopyr   Ú"get_all_pred_and_expr_from_enc_cnfÚfunctionÚ
WHITE_LISTr   Úner   Úkindr	   r
   r   ÚNaNÚextract_pred_from_old_assumÚlenÚencodingÚdataÚappendÚ_preprocessr   Ú
ValueError)ÚpropZ_propZfactbaseZsat_trueZ	sat_falseÚall_predÚ	all_exprsÚpredÚexprZassmÚnZcan_be_trueZcan_be_falser   r   r   r   .   sD    







r   c                 C   s  |   ¡ } d}dd„ | j ¡ D ƒ}i }g }| jD ]¶}g }|D ]œ}|dkr^| |¡ d||< q<|t|ƒ }|dk }	|dk|dk  }
t|ƒ}t|tƒsÄ||kr¬|||< |d7 }|| }| |
| ¡ q<|	rä|j	t
jkräd}	t
j|jŽ }|j	t
jkr|j\}}|	r>t
 ||¡}||kr(|||< |d7 }|| }| |¡ q<nRt
 ||¡t
 ||¡f}|D ]2}||krx|||< |d7 }|| }| |¡ qZq<|j	t
jkr®|	r®ds®t‚||krÈ|||< |d7 }| || |
 ¡ q<| |¡ q.t|ƒ|d ksþt‚t||ƒ} | S )a!  
    Returns an encoded cnf with only Q.eq, Q.gt, Q.lt,
    Q.ge, and Q.le predicate.

    Converts every unequality into a disjunction of strict
    inequalities. For example, x != 3 would become
    x < 3 OR x > 3.

    Also converts all negated Q.ne predicates into
    equalities.
    r   c                 S   s   i | ]\}}||“qS r   r   )Ú.0ÚkeyÚvaluer   r   r   Ú
<dictcomp>r   s      z_preprocess.<locals>.<dictcomp>r   F)r   r!   Úitemsr"   r#   ÚabsÚ_pred_to_binrelÚ
isinstancer   r   r   Úeqr   Ú	argumentsÚgtÚltÚAssertionErrorr    r   )Úenc_cnfZcur_encZrev_encodingZnew_encodingZnew_dataZclauseZ
new_clauseZlitr&   ZnegatedÚsignZarg1Zarg2Znew_propZnew_encZ	new_propsr   r   r   r$   `   sl    









r$   c                 C   sþ   t | tƒs| S | jtkr<t| j }|dkr.dS || jd ƒ} | jtjkr\t | jd d¡} nž| jtjkr|t 	| jd d¡} n~| jtj
krœt | jd d¡} n^| jtjkr¼t | jd d¡} n>| jtjkrÜt | jd d¡} n| jtjkrút | jd d¡} | S )NFr   )r3   r   r   Úpred_to_pos_neg_zeror5   r   Úpositiver6   Únegativer7   Úzeror4   ÚnonpositiveÚleÚnonnegativeÚgeÚnonzeror   )r)   Úfr   r   r   r2   µ   s(    


r2   Fc                 C   sD   t ƒ }t ƒ }| j ¡ D ]$}t|tƒr| |¡ | |j¡ q||fS )N)Úsetr!   Úkeysr3   r   ÚaddÚupdater5   )r9   r(   r'   r)   r   r   r   r   Ø   s    

r   c                 C   sd  g }| D ]T}t |dƒsqt|jƒdkr*q|jdk	rDtd|› dƒ‚t|tƒrrtdd„ |jD ƒƒrrtd|› dƒ‚|j	dkr–|j
dkr–td|› dƒ‚|j	d	kr°td|› d
ƒ‚|jd	krÊtd|› dƒ‚|j
râ| t |¡¡ q|jrú| t |¡¡ q|jr| t |¡¡ q|jr.| t |¡¡ q|jrH| t |¡¡ q|jr| t |¡¡ q|S )ar  
    Returns a list of relevant new assumption predicate
    based on any old assumptions.

    Raises an UnhandledInput exception if any of the assumptions are
    unhandled.

    Ignored predicate:
    - commutative
    - complex
    - algebraic
    - transcendental
    - extended_real
    - real
    - all matrix predicate
    - rational
    - irrational

    Example
    =======
    >>> from sympy.assumptions.lra_satask import extract_pred_from_old_assum
    >>> from sympy import symbols
    >>> x, y = symbols("x y", positive=True)
    >>> extract_pred_from_old_assum([x, y, 2])
    [Q.positive(x), Q.positive(y)]
    Úfree_symbolsr   Tr   z must be realc                 s   s   | ]}|j d k	V  qdS )TN)Úis_real)r,   Úargr   r   r   Ú	<genexpr>  s     z.extract_pred_from_old_assum.<locals>.<genexpr>z is an integerFz can't be an integerz is irational)Úhasattrr    rI   rJ   r   r3   r   ÚanyÚargsÚ
is_integerÚis_zeroZis_rationalr#   r   r>   Zis_positiver<   Zis_negativer=   Z
is_nonzerorC   Zis_nonpositiver?   Zis_nonnegativerA   )r(   Úretr*   r   r   r   r   â   s:    




r   N))Zsympy.assumptions.assumer   Zsympy.assumptions.cnfr   r   Zsympy.assumptions.askr   Zsympy.logic.inferencer   Z!sympy.logic.algorithms.lra_theoryr   r   Zsympy.matrices.kindr	   Zsympy.core.kindr
   r   Zsympy.core.mulr   Zsympy.core.singletonr   r   r<   r=   r>   rC   r?   rA   Zextended_positiveZextended_negativeZextended_nonpositiveZextended_nonzeroZnegative_infiniteZpositive_infiniter   r   r$   r2   r;   r   r   r   r   r   r   Ú<module>   sN       ý2U       ù

