o
    ¦ƒðjá-  ã                   @   sÔ   d Z ddlmZ ddlmZ ddlmZmZ ddlm	Z	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mZ ddlmZ dedefdd„Zdd„ Zddd„Zdd„ Zddd„Zdefdd„ZdS )zJ
Module to evaluate the proposition with assumptions using SAT algorithm.
é    )ÚS)ÚSymbol)Ú
NumberKindÚUndefinedKind)Úget_all_known_matrix_factsÚget_all_known_number_facts)Úglobal_assumptionsÚAppliedPredicate)Úclass_fact_registry)Úoo)Úsatisfiable)ÚCNFÚ
EncodedCNF)Ú
MatrixKindTc           	      C   sj   t  | ¡}t  |  ¡}t  |¡}t ƒ }|r| |¡}t|||||d�}| |¡ |r/| |¡ t|||ƒS )a  
    Function to evaluate the proposition with assumptions using SAT algorithm.

    This function extracts every fact relevant to the expressions composing
    proposition and assumptions. For example, if a predicate containing
    ``Abs(x)`` is proposed, then ``Q.zero(Abs(x)) | Q.positive(Abs(x))``
    will be found and passed to SAT solver because ``Q.nonnegative`` is
    registered as a fact for ``Abs``.

    Proposition is evaluated to ``True`` or ``False`` if the truth value can be
    determined. If not, ``None`` is returned.

    Parameters
    ==========

    proposition : Any boolean expression.
        Proposition which will be evaluated to boolean value.

    assumptions : Any boolean expression, optional.
        Local assumptions to evaluate the *proposition*.

    context : AssumptionsContext, optional.
        Default assumptions to evaluate the *proposition*. By default,
        this is ``sympy.assumptions.global_assumptions`` variable.

    use_known_facts : bool, optional.
        If ``True``, facts from ``sympy.assumptions.ask_generated``
        module are passed to SAT solver as well.

    iterations : int, optional.
        Number of times that relevant facts are recursively extracted.
        Default is infinite times until no new fact is found.

    Returns
    =======

    ``True``, ``False``, or ``None``

    Examples
    ========

    >>> from sympy import Abs, Q
    >>> from sympy.assumptions.satask import satask
    >>> from sympy.abc import x
    >>> satask(Q.zero(Abs(x)), Q.zero(x))
    True

    )Úuse_known_factsÚ
iterations)r   Ú	from_propÚextendÚget_all_relevant_factsÚadd_from_cnfÚcheck_satisfiability)	ÚpropositionÚassumptionsÚcontextr   r   ÚpropsÚ_propsÚcontext_cnfÚsat© r   úš/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/assumptions/satask.pyÚsatask   s   
2

ÿ

r    c                 C   sp   |  ¡ }|  ¡ }| | ¡ | |¡ t|ƒ}t|ƒ}|r |r d S |r&|s&dS |s,|r,dS |s4|s6tdƒ‚d S d S )NTFzInconsistent assumptions)Úcopyr   r   Ú
ValueError)ÚpropÚ_propÚfactbaseÚsat_trueÚ	sat_falseÚcan_be_trueÚcan_be_falser   r   r   r   U   s   

ür   Nc                    sê   t | ƒ‰ |  ¡ }tƒ }|r|| ¡ O }|r|| ¡ O }|tjtjh }d}|tƒ krNtƒ }|D ]}t |ƒ}|ˆ @ tƒ kr@||O }q/|ˆ  }ˆ |O ‰ |tƒ ks*|‡ fdd„|D ƒO }tƒ }	|D ]}
t|
tƒrm|	t|
jƒO }	q^|	 	|
¡ q^|	S )aÍ  
    Extract every expression in the argument of predicates from *proposition*,
    *assumptions* and *context*.

    Parameters
    ==========

    proposition : sympy.assumptions.cnf.CNF

    assumptions : sympy.assumptions.cnf.CNF, optional.

    context : sympy.assumptions.cnf.CNF, optional.
        CNF generated from assumptions context.

    Examples
    ========

    >>> from sympy import Q, Abs
    >>> from sympy.assumptions.cnf import CNF
    >>> from sympy.assumptions.satask import extract_predargs
    >>> from sympy.abc import x, y
    >>> props = CNF.from_prop(Q.zero(Abs(x*y)))
    >>> assump = CNF.from_prop(Q.zero(x) & Q.zero(y))
    >>> extract_predargs(props, assump)
    {x, y, Abs(x*y)}

    Nc                    s"   h | ]}t |ƒˆ @ tƒ kr|’qS r   )Úfind_symbolsÚset)Ú.0Úl©Úreq_keysr   r   Ú	<setcomp>œ   s   " z#extract_predargs.<locals>.<setcomp>)
r*   Úall_predicatesr+   r   ÚtrueÚfalseÚ
isinstancer	   Ú	argumentsÚadd)r   r   r   ÚkeysÚlkeysÚtmp_keysÚtmpr-   ÚsymsÚexprsÚkeyr   r.   r   Úextract_predargsm   s4   
€
ù
r>   c                 C   s8   t | tƒrtƒ }|  ¡ D ]}|t|ƒO }q|S |  t¡S )zƒ
    Find every :obj:`~.Symbol` in *pred*.

    Parameters
    ==========

    pred : sympy.assumptions.cnf.CNF, or any Expr.

    )r4   r   r+   r1   r*   Úatomsr   )ÚpredÚsymbolsÚar   r   r   r*   ¦   s   


r*   c                 C   sn   |st ƒ }tƒ }| D ]&}t|ƒD ]}t  |¡}| |¡}| ¡ D ]}t|tƒr.|t|jƒO }q qq
||  |fS )a2	  
    Extract relevant facts from the items in *exprs*. Facts are defined in
    ``assumptions.sathandlers`` module.

    This function is recursively called by ``get_all_relevant_facts()``.

    Parameters
    ==========

    exprs : set
        Expressions whose relevant facts are searched.

    relevant_facts : sympy.assumptions.cnf.CNF, optional.
        Pre-discovered relevant facts.

    Returns
    =======

    exprs : set
        Candidates for next relevant fact searching.

    relevant_facts : sympy.assumptions.cnf.CNF
        Updated relevant facts.

    Examples
    ========

    Here, we will see how facts relevant to ``Abs(x*y)`` are recursively
    extracted. On the first run, set containing the expression is passed
    without pre-discovered relevant facts. The result is a set containing
    candidates for next run, and ``CNF()`` instance containing facts
    which are relevant to ``Abs`` and its argument.

    >>> from sympy import Abs
    >>> from sympy.assumptions.satask import get_relevant_clsfacts
    >>> from sympy.abc import x, y
    >>> exprs = {Abs(x*y)}
    >>> exprs, facts = get_relevant_clsfacts(exprs)
    >>> exprs
    {x*y}
    >>> facts.clauses #doctest: +SKIP
    {frozenset({Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}),
    frozenset({Literal(Q.zero(Abs(x*y)), False), Literal(Q.zero(x*y), True)}),
    frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True)}),
    frozenset({Literal(Q.zero(Abs(x*y)), True), Literal(Q.zero(x*y), False)}),
    frozenset({Literal(Q.even(Abs(x*y)), False),
                Literal(Q.odd(Abs(x*y)), False),
                Literal(Q.odd(x*y), True)}),
    frozenset({Literal(Q.even(Abs(x*y)), False),
                Literal(Q.even(x*y), True),
                Literal(Q.odd(Abs(x*y)), False)}),
    frozenset({Literal(Q.positive(Abs(x*y)), False),
                Literal(Q.zero(Abs(x*y)), False)})}

    We pass the first run's results to the second run, and get the expressions
    for next run and updated facts.

    >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts)
    >>> exprs
    {x, y}

    On final run, no more candidate is returned thus we know that all
    relevant facts are successfully retrieved.

    >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts)
    >>> exprs
    set()

    )	r   r+   r
   Úto_CNFÚ_andr1   r4   r	   r5   )r<   Úrelevant_factsÚnewexprsÚexprÚfactÚnewfactr=   r   r   r   Úget_relevant_clsfacts¸   s   F


€þýrJ   c                    sP  d}t ƒ }tƒ }	 |dkrt| ||ƒ}||O }t||ƒ\}}|d7 }||kr'n|s*nq	|ržt ƒ }	tdd„ |D ƒƒr?|	 tƒ ¡ tdd„ |D ƒƒrN|	 tƒ ¡ tƒ }
|
 	|	¡ dd„ ‰‡fd	d
„}g }g }t
|
jƒ}t|ƒD ]\}‰ |‡ fdd„|
jD ƒ7 }|||
j|| ƒ7 }qmttt|tdt
|ƒd ƒƒƒƒ}t||ƒ}ntƒ }| |¡ |S )al  
    Extract all relevant facts from *proposition* and *assumptions*.

    This function extracts the facts by recursively calling
    ``get_relevant_clsfacts()``. Extracted facts are converted to
    ``EncodedCNF`` and returned.

    Parameters
    ==========

    proposition : sympy.assumptions.cnf.CNF
        CNF generated from proposition expression.

    assumptions : sympy.assumptions.cnf.CNF
        CNF generated from assumption expression.

    context : sympy.assumptions.cnf.CNF
        CNF generated from assumptions context.

    use_known_facts : bool, optional.
        If ``True``, facts from ``sympy.assumptions.ask_generated``
        module are encoded as well.

    iterations : int, optional.
        Number of times that relevant facts are recursively extracted.
        Default is infinite times until no new fact is found.

    Returns
    =======

    sympy.assumptions.cnf.EncodedCNF

    Examples
    ========

    >>> from sympy import Q
    >>> from sympy.assumptions.cnf import CNF
    >>> from sympy.assumptions.satask import get_all_relevant_facts
    >>> from sympy.abc import x, y
    >>> props = CNF.from_prop(Q.nonzero(x*y))
    >>> assump = CNF.from_prop(Q.nonzero(x))
    >>> context = CNF.from_prop(Q.nonzero(y))
    >>> get_all_relevant_facts(props, assump, context) #doctest: +SKIP
    <sympy.assumptions.cnf.EncodedCNF at 0x7f09faa6ccd0>

    r   Té   c                 s   s   � | ]
}|j ttƒkV  qd S ©N)Úkindr   r   ©r,   rG   r   r   r   Ú	<genexpr>R  s   € z)get_all_relevant_facts.<locals>.<genexpr>c                 s   s$   � | ]}|j tkp|j tkV  qd S rL   )rM   r   r   rN   r   r   r   rO   U  s   €" c                 S   s   | dkr| | S | | S )Nr   r   )ÚlitÚdeltar   r   r   Útranslate_literal[  s   z1get_all_relevant_facts.<locals>.translate_literalc                    s   ‡ ‡fdd„| D ƒS )Nc                    s    g | ]}‡ ‡fd d„|D ƒ‘qS )c                    s   h | ]}ˆ|ˆ ƒ’qS r   r   )r,   Úi©rQ   rR   r   r   r0   b  s    zLget_all_relevant_facts.<locals>.translate_data.<locals>.<listcomp>.<setcomp>r   )r,   ÚclauserT   r   r   Ú
<listcomp>b  s     zBget_all_relevant_facts.<locals>.translate_data.<locals>.<listcomp>r   )ÚdatarQ   )rR   )rQ   r   Útranslate_dataa  s   z.get_all_relevant_facts.<locals>.translate_datac                    s   g | ]}|ˆ ƒ‘qS r   r   )r,   r@   )rG   r   r   rV   g  s    z*get_all_relevant_facts.<locals>.<listcomp>)r   r+   r>   rJ   ÚanyÚadd_clausesr   r   r   Úfrom_cnfÚlenrA   Ú	enumeraterW   ÚdictÚlistÚzipÚranger   )r   r   r   r   r   rS   rE   Ú	all_exprsr<   Úknown_facts_CNFÚ
kf_encodedrX   rW   rA   Ún_litÚencodingÚctxr   )rG   rR   r   r     sF   4÷

 
r   )NNrL   )Ú__doc__Úsympy.core.singletonr   Úsympy.core.symbolr   Úsympy.core.kindr   r   Úsympy.assumptions.ask_generatedr   r   Úsympy.assumptions.assumer   r	   Úsympy.assumptions.sathandlersr
   Ú
sympy.corer   Úsympy.logic.inferencer   Úsympy.assumptions.cnfr   r   Úsympy.matrices.kindr   r    r   r>   r*   rJ   r   r   r   r   r   Ú<module>   s(    
ÿD
9
Vÿ