� ��g�K����dZddlmZmZmZddlmZmZmZddl m Z ddl m Z ddl mZmZmZmZmZmZddlmZddlmZdd lmZmZmZGd �d ��Ze��Zd �Zd efd�Zd�Z d�Z!d�Z"ddl#m$Z$m%Z%dS)z4Module for querying SymPy objects about assumptions.�)�global_assumptions� Predicate�AppliedPredicate)�CNF� EncodedCNF�Literal)�sympify)� BooleanKind)�Eq�Ne�Gt�Lt�Ge�Le)� satisfiable)�memoize_property)�sympy_deprecation_warning�SymPyDeprecationWarning�ignore_warningsc���eZdZdZed���Zed���Zed���Zed���Zed���Z ed���Z ed���Z ed ���Z ed ���Z ed ���Zed ���Zed ���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Zed���Z ed���Z!ed���Z"ed ���Z#ed!���Z$ed"���Z%ed#���Z&ed$���Z'ed%���Z(ed&���Z)ed'���Z*ed(���Z+ed)���Z,ed*���Z-ed+���Z.ed,���Z/ed-���Z0ed.���Z1ed/���Z2ed0���Z3ed1���Z4ed2���Z5ed3���Z6ed4���Z7ed5���Z8ed6���Z9ed7���Z:ed8���Z;ed9���Z<d:S);�AssumptionKeyszy This class contains all the supported keys by ``ask``. It should be accessed via the instance ``sympy.Q``. c�"�ddlm}|��S)N�)�HermitianPredicate)� handlers.setsr)�selfrs �e/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sympy/assumptions/ask.py� hermitianzAssumptionKeys.hermitian �#��5�5�5�5�5�5�!�!�#�#�#�c�"�ddlm}|��S)Nr)�AntihermitianPredicate)rr")rr"s r� antihermitianzAssumptionKeys.antihermitian%s#��9�9�9�9�9�9�%�%�'�'�'r c�"�ddlm}|��S)Nr)� RealPredicate)rr%)rr%s r�realzAssumptionKeys.real*s ��0�0�0�0�0�0��}���r c�"�ddlm}|��S)Nr)�ExtendedRealPredicate)rr()rr(s r� extended_realzAssumptionKeys.extended_real/s#��8�8�8�8�8�8�$�$�&�&�&r c�"�ddlm}|��S)Nr)�ImaginaryPredicate)rr+)rr+s r� imaginaryzAssumptionKeys.imaginary4rr c�"�ddlm}|��S)Nr)�ComplexPredicate)rr.)rr.s r�complexzAssumptionKeys.complex9�#��3�3�3�3�3�3���!�!�!r c�"�ddlm}|��S)Nr)�AlgebraicPredicate)rr2)rr2s r� algebraiczAssumptionKeys.algebraic>rr c�"�ddlm}|��S)Nr)�TranscendentalPredicate)�predicates.setsr5)rr5s r�transcendentalzAssumptionKeys.transcendentalCs#��<�<�<�<�<�<�&�&�(�(�(r c�"�ddlm}|��S)Nr)�IntegerPredicate)rr9)rr9s r�integerzAssumptionKeys.integerHr0r c�"�ddlm}|��S)Nr)�NonIntegerPredicate)r6r<)rr<s r� nonintegerzAssumptionKeys.nonintegerMs#��8�8�8�8�8�8�"�"�$�$�$r c�"�ddlm}|��S)Nr)�RationalPredicate)rr?)rr?s r�rationalzAssumptionKeys.rationalRs#��4�4�4�4�4�4� � �"�"�"r c�"�ddlm}|��S)Nr)�IrrationalPredicate)rrB)rrBs r� irrationalzAssumptionKeys.irrationalWs#��6�6�6�6�6�6�"�"�$�$�$r c�"�ddlm}|��S)Nr)�FinitePredicate)�handlers.calculusrE)rrEs r�finitezAssumptionKeys.finite\�"��6�6�6�6�6�6��� � � r c�"�ddlm}|��S)Nr)�InfinitePredicate)rFrJ)rrJs r�infinitezAssumptionKeys.infinitea�#��8�8�8�8�8�8� � �"�"�"r c�"�ddlm}|��S)Nr)�PositiveInfinitePredicate)rFrN)rrNs r�positive_infinitez AssumptionKeys.positive_infinitef�#��@�@�@�@�@�@�(�(�*�*�*r c�"�ddlm}|��S)Nr)�NegativeInfinitePredicate)rFrR)rrRs r�negative_infinitez AssumptionKeys.negative_infinitekrPr c�"�ddlm}|��S)Nr)�PositivePredicate)�handlers.orderrU)rrUs r�positivezAssumptionKeys.positivep�#��5�5�5�5�5�5� � �"�"�"r c�"�ddlm}|��S)Nr)�NegativePredicate)rVrZ)rrZs r�negativezAssumptionKeys.negativeurXr c�"�ddlm}|��S)Nr)� ZeroPredicate)rVr])rr]s r�zerozAssumptionKeys.zerozs ��1�1�1�1�1�1��}���r c�"�ddlm}|��S)Nr)�ExtendedPositivePredicate)rVr`)rr`s r�extended_positivez AssumptionKeys.extended_positive�#��=�=�=�=�=�=�(�(�*�*�*r c�"�ddlm}|��S)Nr)�ExtendedNegativePredicate)rVrd)rrds r�extended_negativez AssumptionKeys.extended_negative�rbr c�"�ddlm}|��S)Nr)�NonZeroPredicate)rVrg)rrgs r�nonzerozAssumptionKeys.nonzero�s#��4�4�4�4�4�4���!�!�!r c�"�ddlm}|��S)Nr)�NonPositivePredicate)rVrj)rrjs r� nonpositivezAssumptionKeys.nonpositive��#��8�8�8�8�8�8�#�#�%�%�%r c�"�ddlm}|��S)Nr)�NonNegativePredicate)rVrn)rrns r� nonnegativezAssumptionKeys.nonnegative�rlr c�"�ddlm}|��S)Nr)�ExtendedNonZeroPredicate)rVrq)rrqs r�extended_nonzerozAssumptionKeys.extended_nonzero�s#��<�<�<�<�<�<�'�'�)�)�)r c�"�ddlm}|��S)Nr)�ExtendedNonPositivePredicate)rVrt)rrts r�extended_nonpositivez#AssumptionKeys.extended_nonpositive��#��@�@�@�@�@�@�+�+�-�-�-r c�"�ddlm}|��S)Nr)�ExtendedNonNegativePredicate)rVrx)rrxs r�extended_nonnegativez#AssumptionKeys.extended_nonnegative�rvr c�"�ddlm}|��S)Nr)� EvenPredicate)�handlers.ntheoryr{)rr{s r�evenzAssumptionKeys.even�s ��3�3�3�3�3�3��}���r c�"�ddlm}|��S)Nr)� OddPredicate)r|r)rrs r�oddzAssumptionKeys.odd�s ��2�2�2�2�2�2��|�~�~�r c�"�ddlm}|��S)Nr)�PrimePredicate)r|r�)rr�s r�primezAssumptionKeys.prime�s"��4�4�4�4�4�4��~���r c�"�ddlm}|��S)Nr)�CompositePredicate)r|r�)rr�s r� compositezAssumptionKeys.composite�s#��8�8�8�8�8�8�!�!�#�#�#r c�"�ddlm}|��S)Nr)�CommutativePredicate)�handlers.commonr�)rr�s r� commutativezAssumptionKeys.commutative�s#��9�9�9�9�9�9�#�#�%�%�%r c�"�ddlm}|��S)Nr)�IsTruePredicate)r�r�)rr�s r�is_truezAssumptionKeys.is_true�s"��4�4�4�4�4�4��� � � r c�"�ddlm}|��S)Nr)�SymmetricPredicate)�handlers.matricesr�)rr�s r� symmetriczAssumptionKeys.symmetric�s#��9�9�9�9�9�9�!�!�#�#�#r c�"�ddlm}|��S)Nr)�InvertiblePredicate)r�r�)rr�s r� invertiblezAssumptionKeys.invertible��#��:�:�:�:�:�:�"�"�$�$�$r c�"�ddlm}|��S)Nr)�OrthogonalPredicate)r�r�)rr�s r� orthogonalzAssumptionKeys.orthogonal�r�r c�"�ddlm}|��S)Nr)�UnitaryPredicate)r�r�)rr�s r�unitaryzAssumptionKeys.unitary�s#��7�7�7�7�7�7���!�!�!r c�"�ddlm}|��S)Nr)�PositiveDefinitePredicate)r�r�)rr�s r�positive_definitez AssumptionKeys.positive_definite�rPr c�"�ddlm}|��S)Nr)�UpperTriangularPredicate)r�r�)rr�s r�upper_triangularzAssumptionKeys.upper_triangular��#��?�?�?�?�?�?�'�'�)�)�)r c�"�ddlm}|��S)Nr)�LowerTriangularPredicate)r�r�)rr�s r�lower_triangularzAssumptionKeys.lower_triangular�r�r c�"�ddlm}|��S)Nr)�DiagonalPredicate)r�r�)rr�s r�diagonalzAssumptionKeys.diagonal�rLr c�"�ddlm}|��S)Nr)�FullRankPredicate)r�r�)rr�s r�fullrankzAssumptionKeys.fullrank�rLr c�"�ddlm}|��S)Nr)�SquarePredicate)r�r�)rr�s r�squarezAssumptionKeys.square�rHr c�"�ddlm}|��S)Nr)�IntegerElementsPredicate)r�r�)rr�s r�integer_elementszAssumptionKeys.integer_elements�r�r c�"�ddlm}|��S)Nr)�RealElementsPredicate)r�r�)rr�s r� real_elementszAssumptionKeys.real_elements�s#��<�<�<�<�<�<�$�$�&�&�&r c�"�ddlm}|��S)Nr)�ComplexElementsPredicate)r�r�)rr�s r�complex_elementszAssumptionKeys.complex_elementsr�r c�"�ddlm}|��S)Nr)�SingularPredicate)�predicates.matricesr�)rr�s r�singularzAssumptionKeys.singulars#��:�:�:�:�:�:� � �"�"�"r c�"�ddlm}|��S)Nr)�NormalPredicate)r�r�)rr�s r�normalzAssumptionKeys.normal s"��8�8�8�8�8�8��� � � r c�"�ddlm}|��S)Nr)�TriangularPredicate)r�r�)rr�s r� triangularzAssumptionKeys.triangulars#��<�<�<�<�<�<�"�"�$�$�$r c�"�ddlm}|��S)Nr)�UnitTriangularPredicate)r�r�)rr�s r�unit_triangularzAssumptionKeys.unit_triangulars#��@�@�@�@�@�@�&�&�(�(�(r c�"�ddlm}|��S)Nr)�EqualityPredicate)�relation.equalityr�)rr�s r�eqzAssumptionKeys.eqrLr c�"�ddlm}|��S)Nr)�UnequalityPredicate)r�r�)rr�s r�nezAssumptionKeys.ner�r c�"�ddlm}|��S)Nr)�StrictGreaterThanPredicate)r�r�)rr�s r�gtzAssumptionKeys.gt$s#��A�A�A�A�A�A�)�)�+�+�+r c�"�ddlm}|��S)Nr)�GreaterThanPredicate)r�r�)rr�s r�gezAssumptionKeys.ge)s#��;�;�;�;�;�;�#�#�%�%�%r c�"�ddlm}|��S)Nr)�StrictLessThanPredicate)r�r�)rr�s r�ltzAssumptionKeys.lt.s#��>�>�>�>�>�>�&�&�(�(�(r c�"�ddlm}|��S)Nr)�LessThanPredicate)r�r�)rr�s r�lezAssumptionKeys.le3rLr N)=�__name__� __module__� __qualname__�__doc__rrr#r&r)r,r/r3r7r:r=r@rCrGrKrOrSrWr[r^rarerhrkrorrruryr}r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��r rrrs>���������$�$���$��(�(���(��������'�'���'��$�$���$��"�"���"��$�$���$��)�)���)��"�"���"��%�%���%��#�#���#��%�%���%��!�!���!��#�#���#��+�+���+��+�+���+��#�#���#��#�#���#��������+�+���+��+�+���+��"�"���"��&�&���&��&�&���&��*�*���*��.�.���.��.�.���.�������������� � ��� ��$�$���$��&�&���&��!�!���!��$�$���$��%�%���%��%�%���%��"�"���"��+�+���+��*�*���*��*�*���*��#�#���#��#�#���#��!�!���!��*�*���*��'�'���'��*�*���*��#�#���#��!�!���!��%�%���%��)�)���)��#�#���#��%�%���%��,�,���,��&�&���&��)�)���)��#�#���#�#�#r rc��t��}|jD]�}g}|D]}}t|jt��r`t |jj��dkrC|jj|vr3|�t|jj |j �����zn&n$|r"|� t|������t|��S)a� Extract all relevant assumptions from *assump* with respect to given *exprs*. Parameters ========== assump : sympy.assumptions.cnf.CNF exprs : tuple of expressions Returns ======= sympy.assumptions.cnf.CNF Examples ======== >>> from sympy import Q >>> from sympy.assumptions.cnf import CNF >>> from sympy.assumptions.ask import _extract_all_facts >>> from sympy.abc import x, y >>> assump = CNF.from_prop(Q.positive(x) & Q.integer(y)) >>> exprs = (x,) >>> cnf = _extract_all_facts(assump, exprs) >>> cnf.clauses {frozenset({Literal(Q.positive, False)})} r)�set�clauses� isinstance�litr�len� arguments�arg�appendr�function�is_Not�add� frozensetr)�assump�exprs�facts�clause�args�literals r�_extract_all_factsr�;s���< �E�E�E��.�+�+����� +� +�G��'�+�'7�8�8� �S���AV�=W�=W�[\�=\�=\��;�?�e�+�+��K�K��� �(<�g�n� M� M�N�N�N�N��E���� +�� � �)�D�/�/�*�*�*�� �u�:�:�r Tc ���ddlm}ddlm}ddlm}t |��}t |��}t|t��s|j turtd���t|t��s|j turtd���ttjttjt"tjt&tjt*tjt.tji}t|t2��r|j|j}}n5|j|vr|t;|��|j}}ntj|f}}tAj!|��} | �"|��tG| |��} tI��} tK��} | �&tA| ����| �'| ��| j(r#tS| ��durtUd|z���tW|| ��} | �| S||��,|��} | �t[| ��S||||� ��} | �| S ||||� ��} n #|$rYd SwxYw| S) ay Function to evaluate the proposition with assumptions. Explanation =========== This function evaluates the proposition to ``True`` or ``False`` if the truth value can be determined. If not, it returns ``None``. It should be discerned from :func:`~.refine` which, when applied to a proposition, simplifies the argument to symbolic ``Boolean`` instead of Python built-in ``True``, ``False`` or ``None``. **Syntax** * ask(proposition) Evaluate the *proposition* in global assumption context. * ask(proposition, assumptions) Evaluate the *proposition* with respect to *assumptions* in global assumption context. Parameters ========== proposition : Boolean Proposition which will be evaluated to boolean value. If this is not ``AppliedPredicate``, it will be wrapped by ``Q.is_true``. assumptions : Boolean, 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. Returns ======= ``True``, ``False``, or ``None`` Raises ====== TypeError : *proposition* or *assumptions* is not valid logical expression. ValueError : assumptions are inconsistent. Examples ======== >>> from sympy import ask, Q, pi >>> from sympy.abc import x, y >>> ask(Q.rational(pi)) False >>> ask(Q.even(x*y), Q.even(x) & Q.integer(y)) True >>> ask(Q.prime(4*x), Q.integer(x)) False If the truth value cannot be determined, ``None`` will be returned. >>> print(ask(Q.odd(3*x))) # cannot determine unless we know x None ``ValueError`` is raised if assumptions are inconsistent. >>> ask(Q.integer(x), Q.even(x) & Q.odd(x)) Traceback (most recent call last): ... ValueError: inconsistent assumptions Q.even(x) & Q.odd(x) Notes ===== Relations in assumptions are not implemented (yet), so the following will not give a meaningful result. >>> ask(Q.positive(x), x > 0) It is however a work in progress. See Also ======== sympy.assumptions.refine.refine : Simplification using assumptions. Proposition is not reduced to ``None`` if the truth value cannot be determined. r)�satask)� lra_satask)�UnhandledInputz.proposition must be a valid logical expressionz.assumptions must be a valid logical expressionFzinconsistent assumptions %sN)� assumptions�context).�sympy.assumptions.sataskr��sympy.assumptions.lra_sataskr��!sympy.logic.algorithms.lra_theoryr�r r�r�kindr � TypeErrorr �Qr�r r�r r�rr�rr�rr�rr�r��func�typer�r�r� from_prop�extendr��get_all_known_factsr�from_cnf� add_from_cnfr�r� ValueError�_ask_single_fact� _eval_ask�bool)� propositionr�r�r�r�r�� binrelpreds�keyr�� assump_cnf� local_facts�known_facts_cnf�enc_cnf�ress r�askros���t0�/�/�/�/�/�7�7�7�7�7�7�@�@�@�@�@�@��+�&�&�K��+�&�&�K��+�y�)�)�J�[�-=�[�-P�-P��H�I�I�I��+�y�)�)�J�[�-=�[�-P�-P��H�I�I�I��q�t�R���r�1�4��Q�T�2�q�t�R���N�K��+�/�0�0�.��(�+�*?�T��� � �[� (� (���[� 1� 1�2�K�4D�T����I� �~�T����{�+�+�J����g����%�Z��6�6�K�*�+�+�O��l�l�G� ���S��)�)�*�*�*� ����%�%�%���F�{�7�3�3�u�<�<��6��D�E�E�E� �3� � ,� ,�C� ��� � �#�t�*� � �{� +� +�C� ���C�y�y�� �&��+�w� G� G� G�C� ��� ���j��+�w�O�O�O���� �����t�t����� �Js�I+�+I4�3I4c���|jr�t��}t|j��dkr`|j\}t|��dkrD|\}|�|d��}|�|dn t ��}|jr |j|vrdS|jD]S}t|��dkr>|\}|js|�|jd��nd}|��@|\}}||vrdS||vrdS�TdS)a� Compute the truth value of single predicate using assumptions. Parameters ========== key : sympy.assumptions.assume.Predicate Proposition predicate. local_facts : sympy.assumptions.cnf.CNF Local assumption in CNF form. Returns ======= ``True``, ``False`` or ``None`` Examples ======== >>> from sympy import Q >>> from sympy.assumptions.cnf import CNF >>> from sympy.assumptions.ask import _ask_single_fact If prerequisite of proposition is rejected by the assumption, return ``False``. >>> key, assump = Q.zero, ~Q.zero >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) False >>> key, assump = Q.zero, ~Q.even >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) False If assumption implies the proposition, return ``True``. >>> key, assump = Q.even, Q.zero >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) True If proposition rejects the assumption, return ``False``. >>> key, assump = Q.even, Q.odd >>> local_facts = CNF.from_prop(assump) >>> _ask_single_fact(key, local_facts) False rNrFT)r��get_known_facts_dictr��getr�r�r�) r r �known_facts_dict�cl�f� prop_facts�prop_reqr��prop_rejs rrrs ��f��!�/�1�1�� �{�"� #� #�q� (� (��%�C�B��2�w�w�!�|�|����-�1�1�#�t�<�<� �,6�,B�:�a�=�=������8�!���� 1� 1� �5�!�)� !� !�F��6�{�{�a������FG�h�X�-�1�1�!�%��>�>�>�TX� ��%��%/�"��(��(�?�?��4�4��H�_�_� �5�5�� �4r c��tddd���t|t��r |jj}t t |d��}|�|�|��dStt |t||g�����dS)z� Register a handler in the ask system. key must be a string and handler a class inheriting from AskHandler. .. deprecated:: 1.8. Use multipledispatch handler instead. See :obj:`~.Predicate`. z� The AskHandler system is deprecated. The register_handler() function should be replaced with the multipledispatch handler of Predicate. �1.8�deprecated-askhandler��deprecated_since_version�active_deprecations_targetN)�handlers)rr�r�name�getattrr�� add_handler�setattr)r �handler�Qkeys r�register_handlerr'Ys���� �"'�#:� �����#�y�!�!���h�m�� �1�c�4� � �D� �� ����!�!�!�!�!���3� �#�� �:�:�:�;�;�;�;�;r c��tddd���t|t��r |jj}t t ��5t t|���|��ddd��dS#1swxYwYdS)z� Removes a handler from the ask system. .. deprecated:: 1.8. Use multipledispatch handler instead. See :obj:`~.Predicate`. z� The AskHandler system is deprecated. The remove_handler() function should be replaced with the multipledispatch handler of Predicate. rrrN) rr�rr!rrr"r��remove_handler)r r%s rr)r)ss���� �"'�#:� �����#�y�!�!���h�m�� �0� 1� 1�0�0���3���&�&�w�/�/�/�0�0�0�0�0�0�0�0�0�0�0�0����0�0�0�0�0�0s�)A>�>B�B)rrN)&r��sympy.assumptions.assumerrr�sympy.assumptions.cnfrrr� sympy.corer �sympy.core.kindr �sympy.core.relationalr r r rrr�sympy.logic.inferencer�sympy.utilities.decoratorr�sympy.utilities.exceptionsrrrrr�r�rrr'r)�sympy.assumptions.ask_generatedrrr�r r�<module>r3s���:�:�����������:�:�:�:�:�:�:�:�:�:�������'�'�'�'�'�'�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�-�-�-�-�-�-�6�6�6�6�6�6�9�9�9�9�9�9�9�9�9�9�a#�a#�a#�a#�a#�a#�a#�a#�H �N����1�1�1�h"&�/A�T�T�T�T�nP�P�P�f<�<�<�40�0�0�.���������r
Memory