o o hT@s"ddlZddlZddlmZmZddlmZmZmZmZm Z m Z ddl m Z m Z ddlmZmZmZmZmZmZmZddlmZddlmZmZmZddlmZmZmZdd l m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0m1Z1m2Z2dd l-m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlZ?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJmKZKGddde9ZL      d(ddZMdejNee fdeLdejOePgdffddZQdedeLdejOePgdffd d!ZRdd"d#e d$ejSeTd%eTfd&d'ZUdS))N)AddMul)SymbolExprFloatRationalIntegerBasic)UndefinedFunctionFunction) Relational UnequalityEqualityLessThan GreaterThanStrictLessThanStrictGreaterThan)Abs)explogPow)sinhcoshtanh)MinMax) Piecewise)sincostanasinacosatanatan2)AndOrXorImpliesBoolean) BooleanTrue BooleanFalseBooleanFunctionNotITE)Printer)Interval) prec_to_dpsto_str)AppliedPredicate)AppliedBinaryRelation)Q)StrictGreaterThanPredicateStrictLessThanPredicateGreaterThanPredicateLessThanPredicateEqualityPredicatec@sfeZdZUdZdededediiiedede de d e d e d e d eded ed ed ed ed edededediedededededededede de!de"de#de$de%de&d e'd!e(d"d#Z)e*e+d$<e*e+d%<  d]d&e,j-e*fd'd(Z.d)e/fd*d+Z0d,e/d-e,j1e2e3fd.e/fd/d0Z4d1d2Z5d3e6fd4d5Z7d3e8fd6d7Z9d3e:fd8d9Z;d3efdd?ZAd3eBfd@dAZCd3eBfdBdCZDdDeEfdEdFZFdDeGfdGdHZHdDeIfdIdJZJdDefdKdLZKdDeLfdMdNZMdDeNfdOdPZOdDefdQdRZPdDeQfdSdTZRdUdVZSdWdXZTdYdZZUd[d\ZVdS)^ SMTLibPrinter_smtlibNBoolIntReal+*=z<=z>=<>rrabsrrrarcsinarccosarctanarctan2rrrminmaxpowandorxornotitez=>) precision known_typesknown_constantsknown_functions_default_settings symbol_tablesettingscCs|pi}|pi|_t|||jd|_t|jd|_t|jd|_t|jd|_|j D] }| |s;Jq2|j D] }| |sJJqAdS)NrQrRrSrT) rVr.__init__ _settings _precisiondict _known_types_known_constants_known_functionsvalues_is_legal_name)selfrWrV_rci/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/printing/smtlib.pyrXTs   "zSMTLibPrinter.__init__scCs*|sdS|dr dStdd|DS)NFrcss |] }|p |dkVqdS)rbN)isalnum.0rbrcrcrd esz/SMTLibPrinter._is_legal_name..) isnumericall)rarercrcrdr`bszSMTLibPrinter._is_legal_nameopargsreturncs*dfdd|D}d|d|dS)N c3s(|]}t|tr |n|VqdSN) isinstancestr_print)rhararcrdrihs  z(SMTLibPrinter._s_expr..())join)rarlrmargs_strrcrurd_s_exprgszSMTLibPrinter._s_exprcCs||jvr |j|}n8t||jvr|jt|}n)tt|tkr&|j}nt|tr>|j|jvr>|j|j}|||jS|j|}|||j Srp) r^typer namerqr3functionrz argumentsrm)raerlrcrcrd_print_Functionos    zSMTLibPrinter._print_FunctionrcC ||Srprrarrcrcrd_print_Relational~ zSMTLibPrinter._print_RelationalcCrrprrrcrcrd_print_BooleanFunctionrz$SMTLibPrinter._print_BooleanFunctioncCrrprrrcrcrd _print_ExprrzSMTLibPrinter._print_ExprcCsDt||jvr ||S|jt}|jt}|||||jgSrp)r{r^rrr,rzrm)rareq_opnot_oprcrcrd_print_Unequalitys    zSMTLibPrinter._print_Unequalitycs(dtjttfffdd |jS)Nrmc s`|d\}}t|dkr|dust|tsJ|Sjt}||||ddgS)NrT)lenrqr)rsr^r-rz)rmrcrP_print_Piecewise_recursiverarcrdrs    zBSMTLibPrinter._print_Piecewise.._print_Piecewise_recursive)typingUnionlisttuplermrrcrrd_print_Piecewises zSMTLibPrinter._print_PiecewisecCsJ|jjr |jjr dS|jj|jjkrtd|dd|jd|jdS)NzOne-sided intervals (`z`) are not supported in SMT.[z, ])start is_infiniteend ValueErrorrrcrcrd_print_Intervals zSMTLibPrinter._print_IntervalcCs|jtjkrt|jdd}nX|jtjkr t|jdd}nH|jtjkr0t|jdd}n8|jtj kr@t |jdd}n(|jtj krPt |jdd}n|jtj kr`t|jdd}ntd|d||S)Nrz Predicate (`z`) is not handled.)r}r4positivegtr~negativeltzeroeq nonpositivele nonnegativegenonzeroner_print_AppliedBinaryRelation)rarrelrcrcrd_print_AppliedPredicates       z%SMTLibPrinter._print_AppliedPredicatecCs&|jtjkr|t|jS||Srp)r}r4rrr r~rrrcrcrdrs  z*SMTLibPrinter._print_AppliedBinaryRelationxcCdS)Ntruercrarrcrcrd_print_BooleanTruez SMTLibPrinter._print_BooleanTruecCr)Nfalsercrrcrcrd_print_BooleanFalserz!SMTLibPrinter._print_BooleanFalsecCst|j}t|j|dddd}d|vr8|d\}}|ddkr&|dd}|jt}|jt}d||||fS|dvr@td |S) NT) strip_zeros min_fixed max_fixedrrr?rz(%s %s (%s 10 %s)))z+infz-infz)Infinite values are not supported in SMT.) r0_prec mlib_to_str_mpf_splitr^rrr)rardpsstr_realmantrmulrKrcrcrd _print_Floats     zSMTLibPrinter._print_FloatcCs|t|Srp)rsrrrcrcrd _print_floatszSMTLibPrinter._print_floatcCs|d|j|jgS)N/)rzpqrrcrcrd_print_RationalszSMTLibPrinter._print_RationalcCs|jdksJt|jS)Nr)rrrrrrcrcrd_print_Integers zSMTLibPrinter._print_IntegercCst|Srp)rrrrcrcrd _print_intszSMTLibPrinter._print_intcC||jsJ|jSrpr`r|rrcrcrd _print_SymbolzSMTLibPrinter._print_SymbolcCs8|j|}|r |S|jr||jn|}||Srp)r]getrZevalfr)rarr|frcrcrd_print_NumberSymbols  z!SMTLibPrinter._print_NumberSymbolcCrrprrrcrcrd_print_UndefinedFunctionrz&SMTLibPrinter._print_UndefinedFunctioncCs&t|jvr|tdddS||S)NrF)evaluate)rr^rrrrcrcrd _print_Exp1s zSMTLibPrinter._print_Exp1cCstdt|dt|d)NzCannot convert `z ` of type `z ` to SMT.)NotImplementedErrorreprr{)raexprrcrcrd emptyPrinterszSMTLibPrinter.emptyPrinter)NN)W__name__ __module__ __qualname__ printmethodboolintfloatrrrrrrrr9r8r7r6r5rrrrrrr r!r"r#rrrrrrr$r%r&r,r-r'rUr[__annotations__rOptionalrXrrr`rrrrzrr rr+rrrr rrrr/rr2rrr)rr*rrrrrrrrrrrrrrrrcrcrcrdr:s     !"#$%&4  r:Tc spddt|ts|g}dd|D}|si}t|d|i}i} |r(|| d<~|r/|| d<~|r6|| d<~|r=|| d <~|sBg}| sFg} t| |~|D]A} | ttD]8} | jrr| jvrr| j vrrd | d t j | <| j rt | j vrt | j vr| jstd | d qVqNg}|rŇfdd|D}fdd|D}fdd|Dfdd|D}dd|D}|rчfdd|D}dgfdd|Dtdd|Dfdd|Dfdd| DS)aConverts ``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))' cSsdSrprc)rbrcrcrddszsmtlib_code..cSsg|] }tj|ddddqS)TF)strictr convert_xor)sympysympifyrgrcrcrd gszsmtlib_code..rVrQrRrTrSCould 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.cs*i|]}|jD] }|jvr|j|qqSrc) free_symbolsr]r|)rhrsymrrcrd s zsmtlib_code..cs8i|]}|tD]}t|jvr |js |j|q qSrc)atomsr r{r^ is_Piecewiser|)rhrfncrrcrdrscg|]}t|qSrc_auto_declare_smtlib)rhrlog_warnrrcrdr crrcr)rhrrrcrdrrcSsg|]}|r|qSrcrc)rhdeclrcrcrdrscrrc)_auto_assert_smtlibrhrrrcrdrs c$g|]}t|tr |n|qSrcrqrrdoprintrrrcrdrcss|]}|VqdSrprcrrcrcrdriszsmtlib_code..crrcrrrrcrdrrcrrcrrrrcrdrr)rqr_auto_infer_smtlib_typesr:rrr is_Symbolr]rVr is_Functionr{r^r TypeErrorr_rxsorted)r auto_assert auto_declarerQrVrRrSrTprefix_expressionssuffix_expressionsrrWrr declarations constants functionsrcrrd smtlib_code s Y              rrrrcs|jrj|}t|tsJj|}d||gS|jrZjt|}t|s,Jfdd|jD}t |dks>Jdd |ddd}|d}d t|||gS|d |d dS) Nz declare-constcsg|]}j|qSrc)r\rgrrcrdrsz(_auto_declare_smtlib..rrvrorwz declare-funzNon-Symbol/Function `z` will not be declared.) rrVrqr{r\rzrcallable__args__rrx)rrrtype_signatureparams_signaturereturn_signaturercrrdrs   rrcCspt|ts'||jvr|j|tks'|jr.t||jvr.|jt|jdtkr.|d|gS|d|d|S)NrassertzNon-Boolean expression `z6` will not be asserted. Converting to SMTLib verbatim.)rqr(rVrrr{r rz)rrrrcrcrdrs r)rVexprsrVrncsZ|rt|nidtffdd }|dd|Dt|dd|Dt|fdd|Dt|fdd|Dt|d d|Dt|d d|Dtd d |D}d d |Ddd |D}|D]B\}}|vrt|n-|vr||n%|jrt|vrt|jdn|jrtn|j s|j rtn|j rtnd}|r||h|qhS)Nsymsc sH|D]}|js J||}|kr!td|d|d|dqdS)Nrz`. Apparently both `z` and `z`?)r setdefaultr)rinfreold_type_symbolsrcrd safe_updates  z-_auto_infer_smtlib_types..safe_updatecSsh|]}|jr|qSrc)rrrcrcrd s z+_auto_infer_smtlib_types..cSs2h|]}|tD] }|jD]}|jr|qq qSrc)rr+rmr)rhrboolfuncsymbolrcrcrdr s cZh|])}|tD]!}t|vr*t|jt|jD] \}}|jr)|tkr|qq qSrc)rr r{ziprmr rr)rhrrrparamrrcrdr  crrc)rr r{rrmr rr)rhrintfuncrrrrcrdrrcSs&h|]}|tD]}|jr |q qSrc)rr is_integerrhrrrcrcrdr#scSs,h|]}|tD] }|jr |js |q qSrc)rris_realrr rcrcrdr*scSs g|] }|tD]}|q qSrc)rr)rhrrrcrcrdr2s z,_auto_infer_smtlib_types..cS g|] }|jjr|j|jfqSrc)lhsrrhsrhrrcrcrdr3  cSr"rc)r$rr#r%rcrcrdr5r&r) r[setrrrrr{r  is_Booleanr is_Integerr!)rVrrrelsinferreltd inferencercrrdrsn        r) TTNNNNNNNN)Vrr sympy.corerrrrrrrr sympy.core.functionr r sympy.core.relationalr r rrrrr$sympy.functions.elementary.complexesr&sympy.functions.elementary.exponentialrrr%sympy.functions.elementary.hyperbolicrrr(sympy.functions.elementary.miscellaneousrr$sympy.functions.elementary.piecewiser(sympy.functions.elementary.trigonometricrrrr r!r"r#sympy.logic.boolalgr$r%r&r'r(r)r*r+r,r-sympy.printing.printerr. sympy.setsr/mpmath.libmp.libmpfr0r1rsympy.assumptions.assumer2!sympy.assumptions.relation.binrelr3sympy.assumptions.askr4#sympy.assumptions.relation.equalityr5r6r7r8r9r:rrCallablerrrrrr[rrcrcrcrdsR $  $     u ,<"