o
    §ƒðjøT  ã                   @   s"  d dl Z d dl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mZ d dlmZ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 d dlmZmZm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+m,Z, d dl-m.Z.m/Z/m0Z0m1Z1m2Z2 d dl-m3Z3m4Z4m5Z5m6Z6m7Z7 d dl8m9Z9 d dl:m;Z; d dl<m=Z=m>Z? d dl@mAZA d dlBmCZC d dlDmEZE d dlFmGZGmHZHmIZImJZJmKZK G dd„ de9ƒZL						d(dd„ZMde jNeef deLde jOePgdf fdd„ZQdedeLde jOePgdf fd d!„ZRdd"œd#e
d$e jSeT d%eTfd&d'„ZUdS ))é    N)ÚAddÚMul)ÚSymbolÚExprÚFloatÚRationalÚIntegerÚBasic)ÚUndefinedFunctionÚFunction)Ú
RelationalÚ
UnequalityÚEqualityÚLessThanÚGreaterThanÚStrictLessThanÚStrictGreaterThan)ÚAbs)ÚexpÚlogÚPow)ÚsinhÚcoshÚtanh)ÚMinÚMax)Ú	Piecewise)ÚsinÚcosÚtanÚasinÚacosÚatanÚatan2)ÚAndÚOrÚXorÚImpliesÚBoolean)ÚBooleanTrueÚBooleanFalseÚBooleanFunctionÚNotÚITE)ÚPrinter)ÚInterval)Úprec_to_dpsÚto_str)ÚAppliedPredicate)ÚAppliedBinaryRelation)ÚQ)ÚStrictGreaterThanPredicateÚStrictLessThanPredicateÚGreaterThanPredicateÚLessThanPredicateÚEqualityPredicatec                   @   sf  e Zd ZU dZdedededii i ed“ed“e	d“e
d	“ed
“ed“ed“eƒ d“eƒ d	“eƒ d
“eƒ d“eƒ d“ed“ed“ed“ed“ed“i ed“ed“ed“ed“ed“ed“ed“ed“e d“e!d“e"d“e#d“e$d“e%d“e&d “e'd!“e(d"“¥d#œZ)e*e+d$< e*e+d%< 		d]d&e,j-e* fd'd(„Z.d)e/fd*d+„Z0d,e/d-e,j1e2e3f d.e/fd/d0„Z4d1d2„ Z5d3e6fd4d5„Z7d3e8fd6d7„Z9d3e:fd8d9„Z;d3e<fd:d;„Z=d3e>fd<d=„Z?d3e@fd>d?„ZAd3eBfd@dA„ZCd3eBfdBdC„ZDdDeEfdEdF„ZFdDeGfdGdH„ZHdDeIfdIdJ„ZJdDefdKdL„ZKdDeLfdMdN„ZMdDeNfdOdP„ZOdDefdQdR„ZPdDeQfdSdT„ZRdUdV„ ZSdWdX„ ZTdYdZ„ ZUd[d\„ ZVdS )^ÚSMTLibPrinterÚ_smtlibNÚBoolÚIntÚRealú+Ú*ú=z<=z>=ú<ú>r   r   Úabsr   r   r   ÚarcsinÚarccosÚarctanÚarctan2r   r   r   ÚminÚmaxÚpowÚandÚorÚxorÚnotÚitez=>)Ú	precisionÚknown_typesÚknown_constantsÚknown_functionsÚ_default_settingsÚsymbol_tableÚsettingsc                 C   sš   |pi }|pi | _ t | |¡ | jd | _t| jd ƒ| _t| jd ƒ| _t| jd ƒ| _| j 	¡ D ]	}|  
|¡s;J ‚q2| j 	¡ D ]	}|  
|¡sJJ ‚qAd S )NrQ   rR   rS   rT   )rV   r.   Ú__init__Ú	_settingsÚ
_precisionÚdictÚ_known_typesÚ_known_constantsÚ_known_functionsÚvaluesÚ_is_legal_name)ÚselfrW   rV   Ú_© rc   ú—/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/printing/smtlib.pyrX   T   s   
"zSMTLibPrinter.__init__Úsc                 C   s*   |sdS |d   ¡ rdS tdd„ |D ƒƒS )NFr   c                 s   s    � | ]}|  ¡ p|d kV  qdS )rb   N)Úisalnum©Ú.0rb   rc   rc   rd   Ú	<genexpr>e   s   € z/SMTLibPrinter._is_legal_name.<locals>.<genexpr>)Ú	isnumericÚall)ra   re   rc   rc   rd   r`   b   s   zSMTLibPrinter._is_legal_nameÚopÚargsÚreturnc                    s*   d  ‡ fdd„|D ƒ¡}d|› d|› d�S )Nú c                 3   s(   � | ]}t |tƒr|nˆ  |¡V  qd S ©N)Ú
isinstanceÚstrÚ_print)rh   Úa©ra   rc   rd   ri   h   s   € þ
þz(SMTLibPrinter._s_expr.<locals>.<genexpr>ú(ú))Újoin)ra   rl   rm   Úargs_strrc   ru   rd   Ú_s_exprg   s   ýzSMTLibPrinter._s_exprc                 C   s”   || j v r| j | }n8t|ƒ| j v r| j t|ƒ }n)tt|ƒƒtkr&|j}nt|tƒr>|j| j v r>| j |j }|  ||j¡S | j | }|  ||j	¡S rp   )
r^   Útyper
   Únamerq   r3   Úfunctionrz   Ú	argumentsrm   )ra   Úerl   rc   rc   rd   Ú_print_Functiono   s   

zSMTLibPrinter._print_Functionr   c                 C   ó
   |   |¡S rp   ©r€   ©ra   r   rc   rc   rd   Ú_print_Relational~   ó   
zSMTLibPrinter._print_Relationalc                 C   r�   rp   r‚   rƒ   rc   rc   rd   Ú_print_BooleanFunction�   r…   z$SMTLibPrinter._print_BooleanFunctionc                 C   r�   rp   r‚   rƒ   rc   rc   rd   Ú_print_Expr„   r…   zSMTLibPrinter._print_Exprc                 C   sD   t |ƒ| jv r|  |¡S | jt }| jt }|  ||  ||j¡g¡S rp   )r{   r^   r„   r   r,   rz   rm   )ra   r   Úeq_opÚnot_oprc   rc   rd   Ú_print_Unequality‡   s
   


zSMTLibPrinter._print_Unequalityc                    s(   dt jttf f‡ ‡fdd„‰ ˆ |jƒS )Nrm   c              	      s`   | d \}}t | ƒdkr|du st|tƒsJ ‚ˆ |¡S ˆjt }ˆ |||ˆ | dd … ƒg¡S )Nr   é   T)Úlenrq   r)   rs   r^   r-   rz   )rm   r   ÚcrP   ©Ú_print_Piecewise_recursivera   rc   rd   r�   �   s   

ÿzBSMTLibPrinter._print_Piecewise.<locals>._print_Piecewise_recursive)ÚtypingÚUnionÚlistÚtuplerm   rƒ   rc   rŽ   rd   Ú_print_Piecewise�   s   
zSMTLibPrinter._print_Piecewisec                 C   sJ   |j jr
|jjr
dS |j j|jjkrtd|› d�ƒ‚d|j › d|j› d�S )NÚ zOne-sided intervals (`z`) are not supported in SMT.ú[z, ú])ÚstartÚis_infiniteÚendÚ
ValueErrorrƒ   rc   rc   rd   Ú_print_Interval�   s
   zSMTLibPrinter._print_Intervalc                 C   sÚ   |j tjkrt |jd d¡}nX|j tjkr t |jd d¡}nH|j tjkr0t |jd d¡}n8|j tj	kr@t 
|jd d¡}n(|j tjkrPt |jd d¡}n|j tjkr`t |jd d¡}ntd|› d�ƒ‚|  |¡S )Nr   zPredicate (`z`) is not handled.)r}   r4   ÚpositiveÚgtr~   ÚnegativeÚltÚzeroÚeqÚnonpositiveÚleÚnonnegativeÚgeÚnonzeroÚner›   Ú_print_AppliedBinaryRelation)ra   r   Úrelrc   rc   rd   Ú_print_AppliedPredicate¥   s   
z%SMTLibPrinter._print_AppliedPredicatec                 C   s&   |j tjkr|  t|jŽ ¡S |  |¡S rp   )r}   r4   r¨   rŠ   r   r~   r€   rƒ   rc   rc   rd   r©   ·   s   
z*SMTLibPrinter._print_AppliedBinaryRelationÚxc                 C   ó   dS )NÚtruerc   ©ra   r¬   rc   rc   rd   Ú_print_BooleanTrueÊ   ó   z SMTLibPrinter._print_BooleanTruec                 C   r­   )NÚfalserc   r¯   rc   rc   rd   Ú_print_BooleanFalseÍ   r±   z!SMTLibPrinter._print_BooleanFalsec                 C   s„   t |jƒ}t|j|dd d d�}d|v r8| d¡\}}|d dkr&|dd … }| jt }| jt }d||||f S |dv r@td	ƒ‚|S )
NT)Ústrip_zerosÚ	min_fixedÚ	max_fixedr   r   r?   r‹   z(%s %s (%s 10 %s)))z+infz-infz)Infinite values are not supported in SMT.)	r0   Ú_precÚmlib_to_strÚ_mpf_Úsplitr^   r   r   r›   )ra   r¬   ÚdpsÚstr_realÚmantr   ÚmulrK   rc   rc   rd   Ú_print_FloatÐ   s   


zSMTLibPrinter._print_Floatc                 C   s   |   t|ƒ¡S rp   )rs   r   r¯   rc   rc   rd   Ú_print_floatã   s   zSMTLibPrinter._print_floatc                 C   s   |   d|j|jg¡S )Nú/)rz   ÚpÚqr¯   rc   rc   rd   Ú_print_Rationalæ   s   zSMTLibPrinter._print_Rationalc                 C   s   |j dksJ ‚t|jƒS )Nr‹   )rÃ   rr   rÂ   r¯   rc   rc   rd   Ú_print_Integeré   s   
zSMTLibPrinter._print_Integerc                 C   s   t |ƒS rp   )rr   r¯   rc   rc   rd   Ú
_print_intí   s   zSMTLibPrinter._print_intc                 C   ó   |   |j¡sJ ‚|jS rp   ©r`   r|   r¯   rc   rc   rd   Ú_print_Symbolð   ó   zSMTLibPrinter._print_Symbolc                 C   s8   | j  |¡}|r
|S | jr| | j¡n| ¡ }|  |¡S rp   )r]   ÚgetrZ   Úevalfr¿   )ra   r¬   r|   Úfrc   rc   rd   Ú_print_NumberSymbolô   s
   
z!SMTLibPrinter._print_NumberSymbolc                 C   rÇ   rp   rÈ   r¯   rc   rc   rd   Ú_print_UndefinedFunctionü   rÊ   z&SMTLibPrinter._print_UndefinedFunctionc                 C   s&   t | jv r|  t ddd�¡S |  |¡S )Nr‹   F)Úevaluate)r   r^   r€   rÎ   r¯   rc   rc   rd   Ú_print_Exp1   s
   
ÿÿýzSMTLibPrinter._print_Exp1c                 C   s   t dt|ƒ› dt|ƒ› d�ƒ‚)NzCannot convert `z` of type `z	` to SMT.)ÚNotImplementedErrorÚreprr{   )ra   Úexprrc   rc   rd   ÚemptyPrinter  s   zSMTLibPrinter.emptyPrinter)NN)WÚ__name__Ú
__module__Ú__qualname__ÚprintmethodÚboolÚintÚfloatr   r   r   r   r   r   r   r9   r8   r7   r6   r5   r   r   r   r   r   r   r    r!   r"   r#   r   r   r   r   r   r   r$   r%   r&   r,   r-   r'   rU   r[   Ú__annotations__r�   ÚOptionalrX   rr   r`   r‘   r’   r“   rz   r€   r   r„   r+   r†   r   r‡   r   rŠ   r   r”   r/   rœ   r2   r«   r©   r)   r°   r*   r³   r   r¿   rÀ   r   rÄ   r   rÅ   rÆ   r   rÉ   rÎ   rÏ   rÑ   rÕ   rc   rc   rc   rd   r:      sÒ   
 ýÿþüûúùø
öõôóòðïîíìëêéèçæåäãâá!ß"Þ#Ý$Ü%Û&Úö4ÿ r:   Tc                    sô  ˆ pdd„ ‰ t | tƒs| g} dd„ | D ƒ} |si }t| d|iŽ}i }|r(||d< ~|r/||d< ~|r6||d< ~|r=||d	< ~|sBg }|	sFg }	t||ƒ‰~| D ]A}| tt¡D ]8}|jrr|ˆjvrr|ˆj	vrrˆ d
|› d�ƒ t
ˆj	|< |jrŽt|ƒˆjvrŽt|ƒˆj	vrŽ|jsŽtd|› d�ƒ‚qVqNg }|rÅ‡fdd„| D ƒ}‡fdd„| D ƒ}‡ ‡fdd„| ¡ D ƒ‡ ‡fdd„| ¡ D ƒ }dd„ |D ƒ}|rÑ‡ ‡fdd„| D ƒ} d g ‡fdd„|D ƒ¢tdd„ |D ƒƒ¢‡fdd„| D ƒ¢‡fdd„|	D ƒ¢¡S )aß  Converts ``expr`` to a string of smtlib code.

    Parameters
    ==========

    expr : Expr | List[Expr]
        A SymPy expression or system to be converted.
    auto_assert : bool, optional
        If false, do not modify expr and produce only the S-Expression equivalent of expr.
        If true, assume expr is a system and assert each boolean element.
    auto_declare : bool, optional
        If false, do not produce declarations for the symbols used in expr.
        If true, prepend all necessary declarations for variables used in expr based on symbol_table.
    precision : integer, optional
        The ``evalf(..)`` precision for numbers such as pi.
    symbol_table : dict, optional
        A dictionary where keys are ``Symbol`` or ``Function`` instances and values are their Python type i.e. ``bool``, ``int``, ``float``, or ``Callable[...]``.
        If incomplete, an attempt will be made to infer types from ``expr``.
    known_types: dict, optional
        A dictionary where keys are ``bool``, ``int``, ``float`` etc. and values are their corresponding SMT type names.
        If not given, a partial listing compatible with several solvers will be used.
    known_functions : dict, optional
        A dictionary where keys are ``Function``, ``Relational``, ``BooleanFunction``, or ``Expr`` instances and values are their SMT string representations.
        If not given, a partial listing optimized for dReal solver (but compatible with others) will be used.
    known_constants: dict, optional
        A dictionary where keys are ``NumberSymbol`` instances and values are their SMT variable names.
        When using this feature, extra caution must be taken to avoid naming collisions between user symbols and listed constants.
        If not given, constants will be expanded inline i.e. ``3.14159`` instead of ``MY_SMT_VARIABLE_FOR_PI``.
    prefix_expressions: list, optional
        A list of lists of ``str`` and/or expressions to convert into SMTLib and prefix to the output.
    suffix_expressions: list, optional
        A list of lists of ``str`` and/or expressions to convert into SMTLib and postfix to the output.
    log_warn: lambda function, optional
        A function to record all warnings during potentially risky operations.
        Soundness is a core value in SMT solving, so it is good to log all assumptions made.

    Examples
    ========
    >>> from sympy import smtlib_code, symbols, sin, Eq
    >>> x = symbols('x')
    >>> smtlib_code(sin(x).series(x).removeO(), log_warn=print)
    Could not infer type of `x`. Defaulting to float.
    Non-Boolean expression `x**5/120 - x**3/6 + x` will not be asserted. Converting to SMTLib verbatim.
    '(declare-const x Real)\n(+ x (* (/ -1 6) (pow x 3)) (* (/ 1 120) (pow x 5)))'

    >>> from sympy import Rational
    >>> x, y, tau = symbols("x, y, tau")
    >>> smtlib_code((2*tau)**Rational(7, 2), log_warn=print)
    Could not infer type of `tau`. Defaulting to float.
    Non-Boolean expression `8*sqrt(2)*tau**(7/2)` will not be asserted. Converting to SMTLib verbatim.
    '(declare-const tau Real)\n(* 8 (pow 2 (/ 1 2)) (pow tau (/ 7 2)))'

    ``Piecewise`` expressions are implemented with ``ite`` expressions by default.
    Note that if the ``Piecewise`` lacks a default term, represented by
    ``(expr, True)`` then an error will be thrown.  This is to prevent
    generating an expression that may not evaluate to anything.

    >>> from sympy import Piecewise
    >>> pw = Piecewise((x + 1, x > 0), (x, True))
    >>> smtlib_code(Eq(pw, 3), symbol_table={x: float}, log_warn=print)
    '(declare-const x Real)\n(assert (= (ite (> x 0) (+ 1 x) x) 3))'

    Custom printing can be defined for certain types by passing a dictionary of
    PythonType : "SMT Name" to the ``known_types``, ``known_constants``, and ``known_functions`` kwargs.

    >>> from typing import Callable
    >>> from sympy import Function, Add
    >>> f = Function('f')
    >>> g = Function('g')
    >>> smt_builtin_funcs = {  # functions our SMT solver will understand
    ...   f: "existing_smtlib_fcn",
    ...   Add: "sum",
    ... }
    >>> user_def_funcs = {  # functions defined by the user must have their types specified explicitly
    ...   g: Callable[[int], float],
    ... }
    >>> smtlib_code(f(x) + g(x), symbol_table=user_def_funcs, known_functions=smt_builtin_funcs, log_warn=print)
    Non-Boolean expression `f(x) + g(x)` will not be asserted. Converting to SMTLib verbatim.
    '(declare-const x Int)\n(declare-fun g (Int) Real)\n(sum (existing_smtlib_fcn x) (g x))'
    c                 S   s   d S rp   rc   )rb   rc   rc   rd   Ú<lambda>d  s    zsmtlib_code.<locals>.<lambda>c                 S   s   g | ]}t j|d ddd�‘qS )TF)ÚstrictrÐ   Úconvert_xor)ÚsympyÚsympifyrg   rc   rc   rd   Ú
<listcomp>g  s    ÿÿzsmtlib_code.<locals>.<listcomp>rV   rQ   rR   rT   rS   úCould not infer type of `z`. Defaulting to float.z$Unknown type of undefined function `z^`. Must be mapped to ``str`` in known_functions or mapped to ``Callable[..]`` in symbol_table.c                    s*   i | ]}|j D ]}|ˆ jvr|j|“qqS rc   )Úfree_symbolsr]   r|   )rh   r   Úsym©rÂ   rc   rd   Ú
<dictcomp>œ  s    
ÿzsmtlib_code.<locals>.<dictcomp>c                    s8   i | ]}|  t¡D ]}t|ƒˆ jvr	|js	|j|“q	qS rc   )Úatomsr   r{   r^   Úis_Piecewiser|   )rh   r   Úfncrè   rc   rd   ré   ž  s    ÿc                    ó   g | ]}t |ˆˆ ƒ‘qS rc   ©Ú_auto_declare_smtlib)rh   rç   ©Úlog_warnrÂ   rc   rd   rä   ¡  ó    
ÿÿc                    rí   rc   rî   )rh   rì   rð   rc   rd   rä   ¤  rò   c                 S   s   g | ]}|r|‘qS rc   rc   )rh   Údeclrc   rc   rd   rä   ¨  s    c                    rí   rc   )Ú_auto_assert_smtlib©rh   r   rð   rc   rd   rä   «  s    Ú
c                    ó$   g | ]}t |tƒr|nˆ  |¡‘qS rc   ©rq   rr   Údoprintrõ   rè   rc   rd   rä   °  ó    ÿÿc                 s   s   � | ]}|V  qd S rp   rc   rõ   rc   rc   rd   ri   ¶  s   € zsmtlib_code.<locals>.<genexpr>c                    r÷   rc   rø   rõ   rè   rc   rd   rä   ¹  rú   c                    r÷   rc   rø   rõ   rè   rc   rd   rä   ¿  rú   )rq   r’   Ú_auto_infer_smtlib_typesr:   rê   r   r   Ú	is_Symbolr]   rV   rÜ   Úis_Functionr{   r^   rë   Ú	TypeErrorr_   rx   Úsorted)rÔ   Úauto_assertÚauto_declarerQ   rV   rR   rS   rT   Úprefix_expressionsÚsuffix_expressionsrñ   rW   r   rç   ÚdeclarationsÚ	constantsÚ	functionsrc   rð   rd   Úsmtlib_code  s’   Yþÿÿ
ÿ


ÿÿ
ÿ€óþþýÿ
þþø
þõ
þïr  rç   rÂ   rñ   c                    sÈ   | j rˆ j|  }t|tƒsJ ‚ˆ j| }ˆ  d| |g¡S | jrZˆ jt| ƒ }t|ƒs,J ‚‡ fdd„|jD ƒ}t	|ƒdks>J ‚dd 
|d d… ¡› d�}|d }ˆ  d	t| ƒ||g¡S |d
| › d�ƒ d S )Nzdeclare-constc                    s   g | ]}ˆ j | ‘qS rc   )r\   rg   rè   rc   rd   rä   Ð  s    z(_auto_declare_smtlib.<locals>.<listcomp>r   rv   ro   éÿÿÿÿrw   zdeclare-funzNon-Symbol/Function `z` will not be declared.)rü   rV   rq   r{   r\   rz   rý   ÚcallableÚ__args__rŒ   rx   )rç   rÂ   rñ   Útype_signatureÚparams_signatureÚreturn_signaturerc   rè   rd   rï   Æ  s   

rï   r   c                 C   sp   t | tƒs'| |jv r|j|  tks'| jr.t| ƒ|jv r.|jt| ƒ jd tkr.| d| g¡S |d| › d�ƒ | S )Nr  ÚassertzNon-Boolean expression `z6` will not be asserted. Converting to SMTLib verbatim.)rq   r(   rV   rÚ   rý   r{   r
  rz   )r   rÂ   rñ   rc   rc   rd   rô   Û  s   
þrô   )rV   ÚexprsrV   rn   c                    sZ  | rt | ƒni ‰ dtf‡ fdd„}|dd„ |D ƒtƒ |dd„ |D ƒtƒ |‡ fdd„|D ƒtƒ |‡ fdd„|D ƒtƒ |d	d„ |D ƒtƒ |d
d„ |D ƒtƒ dd„ |D ƒ}dd„ |D ƒdd„ |D ƒ }|D ]B\}}|ˆ v rtˆ | n-|ˆ v r|ˆ | n%|jrŽt|ƒˆ v rŽˆ t|ƒ jd n|jr“tn|j	s™|j
r›tn|jr tnd }|rª||h|ƒ qhˆ S )NÚsymsc              	      sH   | D ]}|j s	J ‚ˆ  ||¡ }|kr!td|› d|› d|› d�ƒ‚qd S )Nrå   z`. Apparently both `z` and `z`?)rü   Ú
setdefaultrþ   )r  Úinfre   Úold_type©Ú_symbolsrc   rd   Úsafe_updateü  s   
ÿþz-_auto_infer_smtlib_types.<locals>.safe_updatec                 S   s   h | ]}|j r|’qS rc   )rü   rõ   rc   rc   rd   Ú	<setcomp>  s    ýÿz+_auto_infer_smtlib_types.<locals>.<setcomp>c                 S   s2   h | ]}|  t¡D ]}|jD ]}|jr|’qq	qS rc   )rê   r+   rm   rü   )rh   r   ÚboolfuncÚsymbolrc   rc   rd   r  	  s    ýüû
ÿc                    óZ   h | ])}|  t¡D ]!}t|ƒˆ v r*t|jˆ t|ƒ jƒD ]\}}|jr)|tkr|’qq	qS rc   )rê   r   r{   Úziprm   r
  rü   rÚ   )rh   r   r  r  Úparamr  rc   rd   r    ó    ýÿþû
c                    r  rc   )rê   r   r{   r  rm   r
  rü   rÛ   )rh   r   Úintfuncr  r  r  rc   rd   r    r  c                 S   s&   h | ]}|  t¡D ]}|jr	|’q	qS rc   )rê   r   Ú
is_integer©rh   r   r  rc   rc   rd   r  #  s    ýüÿc                 S   s,   h | ]}|  t¡D ]
}|jr	|js	|’q	qS rc   )rê   r   Úis_realr  r   rc   rc   rd   r  *  s    ýüüÿc                 S   s    g | ]}|  t¡D ]}|‘q	qS rc   )rê   r   )rh   rÔ   rª   rc   rc   rd   rä   2  s     z,_auto_infer_smtlib_types.<locals>.<listcomp>c                 S   ó    g | ]}|j jr|j |jf‘qS rc   )Úlhsrü   Úrhs©rh   rª   rc   rc   rd   rä   3  ó
    ÿ
ÿc                 S   r"  rc   )r$  rü   r#  r%  rc   rc   rd   rä   5  r&  r  )r[   ÚsetrÚ   rÛ   rÜ   rý   r{   r
  Ú
is_Booleanr  Ú
is_Integerr!  )rV   r  r  Úrels_eqÚrelsÚinferÚreltdÚ	inferencerc   r  rd   rû   é  sn   þüþúþù	þù	þûþûÿÿþÿÿ

ö€rû   )
TTNNNNNNNN)Vr�   râ   Ú
sympy.corer   r   r   r   r   r   r   r	   Úsympy.core.functionr
   r   Úsympy.core.relationalr   r   r   r   r   r   r   Ú$sympy.functions.elementary.complexesr   Ú&sympy.functions.elementary.exponentialr   r   r   Ú%sympy.functions.elementary.hyperbolicr   r   r   Ú(sympy.functions.elementary.miscellaneousr   r   Ú$sympy.functions.elementary.piecewiser   Ú(sympy.functions.elementary.trigonometricr   r   r   r    r!   r"   r#   Úsympy.logic.boolalgr$   r%   r&   r'   r(   r)   r*   r+   r,   r-   Úsympy.printing.printerr.   Ú
sympy.setsr/   Úmpmath.libmp.libmpfr0   r1   r¸   Úsympy.assumptions.assumer2   Ú!sympy.assumptions.relation.binrelr3   Úsympy.assumptions.askr4   Ú#sympy.assumptions.relation.equalityr5   r6   r7   r8   r9   r:   r  r‘   ÚCallablerr   rï   rô   rÞ   r[   rû   rc   rc   rc   rd   Ú<module>   sR     $$ u
ù ,<"þÿþý