� ��g�0��"�dZddlmZmZmZddlmZmZddlm Z m Z m Z m Z m Z mZddlmZddlmZmZmZmZddlmZmZmZmZmZmZGd�d ��ZGd �d ��ZGd �d ��Zdd�Zd�Z Gd�d��Z!Gd�d��Z"dS)a  The classes used here are for the internal use of assumptions system only and should not be used anywhere else as these do not possess the signatures common to SymPy objects. For general use of logic constructs please refer to sympy.logic classes And, Or, Not, etc. �)� combinations�product� zip_longest)�AppliedPredicate� Predicate)�Eq�Ne�Gt�Lt�Ge�Le)�S)�Or�And�Not�Xnor)� Equivalent�ITE�Implies�Nand�Nor�Xorc�\��eZdZdZd �fd� Zed���Zd�Zd�Zd�Z e Z d�Z d �Z �xZ S) �Literala{ The smallest element of a CNF object. Parameters ========== lit : Boolean expression is_Not : bool Examples ======== >>> from sympy import Q >>> from sympy.assumptions.cnf import Literal >>> from sympy.abc import x >>> Literal(Q.even(x)) Literal(Q.even(x), False) >>> Literal(~Q.even(x)) Literal(Q.even(x), True) Fc���t|t��r|jd}d}n)t|ttt f��r|r|n|St ���|��}||_||_ |S)NrT) � isinstancer�args�AND�ORr�super�__new__�lit�is_Not)�clsr"r#�obj� __class__s ��e/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sympy/assumptions/cnf.pyr!zLiteral.__new__&sy��� �c�3� � � +��(�1�+�C��F�F� ��c�2�w�/� 0� 0� +�!�*�C�4�4�s� *��g�g�o�o�c�"�"������� �� �c��|jS�N�r"��selfs r'�argz Literal.arg1s ���x�r(c���t|j��r|�|��}n|j�|��}t|��||j��Sr*)�callabler"�apply�typer#)r-�exprr"s r'�rcallz Literal.rcall5sR�� �D�H� � � '��(�(�4�.�.�C�C��(�.�.��&�&�C��t�D�z�z�#�t�{�+�+�+r(c�<�|j }t|j|��Sr*)r#rr")r-r#s r'� __invert__zLiteral.__invert__<s���[����t�x��(�(�(r(c�h�d�t|��j|j|j��S)Nz {}({}, {}))�formatr2�__name__r"r#r,s r'�__str__zLiteral.__str__@s'���"�"�4��:�:�#6���$�+�N�N�Nr(c�B�|j|jko|j|jkSr*)r.r#�r-�others r'�__eq__zLiteral.__eq__Es���x�5�9�$�D���� �)D�Dr(c�b�tt|��j|j|jf��}|Sr*)�hashr2r9r.r#)r-�hs r'�__hash__zLiteral.__hash__Hs(�� �$�t�*�*�%�t�x���=� >� >���r()F)r9� __module__� __qualname__�__doc__r!�propertyr.r4r6r:�__repr__r>rB� __classcell__)r&s@r'rrs����������, � � � � � �����X��,�,�,�)�)�)�O�O�O��H�E�E�E�������r(rc�P�eZdZdZd�Zed���Zd�Zd�Zd�Z d�Z d�Z e Z d S) rz+ A low-level implementation for Or c��||_dSr*��_args�r-rs r'�__init__z OR.__init__Q� ���� � � r(c�8�t|jt���S�N)�key��sortedrL�strr,s r'rzOR.argsT����d�j�c�*�*�*�*r(c�J��t|���fd�|jD���S)Nc�:��g|]}|������S��r4��.0r.r3s �r'� <listcomp>zOR.rcall.<locals>.<listcomp>Y�3������ #� �I�I�d�O�O���r(�r2rL�r-r3s `r'r4zOR.rcallX�@����t�D�z�z�����'+�z����� r(c�2�td�|jD���S)Nc��g|]}|��SrYrY�r\r.s r'r]z!OR.__invert__.<locals>.<listcomp>^s��0�0�0�c�c�T�0�0�0r()rrLr,s r'r6z OR.__invert__]s���0�0�T�Z�0�0�0�1�1r(c�p�tt|��jft|j��z��Sr*�r@r2r9�tuplerr,s r'rBz OR.__hash__`�+���T�$�Z�Z�(�*�U�4�9�-=�-=�=�>�>�>r(c�"�|j|jkSr*�rr<s r'r>z OR.__eq__c����y�E�J�&�&r(c�Z�dd�d�|jD����zdz}|S)N�(� | c�,�g|]}t|����SrY�rUrds r'r]zOR.__str__.<locals>.<listcomp>gs��<�<�<�3�c�#�h�h�<�<�<r(�)��joinr�r-�ss r'r:z OR.__str__fs3�� �%�*�*�<�<�$�)�<�<�<�=�=� =�� C���r(N) r9rCrDrErNrFrr4r6rBr>r:rGrYr(r'rrMs�������������+�+��X�+���� 2�2�2�?�?�?�'�'�'�����H�H�Hr(rc�P�eZdZdZd�Zd�Zed���Zd�Zd�Z d�Z d�Z e Z d S) rz, A low-level implementation for And c��||_dSr*rKrMs r'rNz AND.__init__qrOr(c�2�td�|jD���S)Nc��g|]}|��SrYrYrds r'r]z"AND.__invert__.<locals>.<listcomp>us��/�/�/�S�S�D�/�/�/r()rrLr,s r'r6zAND.__invert__ts���/�/�D�J�/�/�/�0�0r(c�8�t|jt���SrQrSr,s r'rzAND.argswrVr(c�J��t|���fd�|jD���S)Nc�:��g|]}|������SrYrZr[s �r'r]zAND.rcall.<locals>.<listcomp>|r^r(r_r`s `r'r4z AND.rcall{rar(c�p�tt|��jft|j��z��Sr*rfr,s r'rBz AND.__hash__�rhr(c�"�|j|jkSr*rjr<s r'r>z AND.__eq__�rkr(c�Z�dd�d�|jD����zdz}|S)Nrm� & c�,�g|]}t|����SrYrprds r'r]zAND.__str__.<locals>.<listcomp>�s��:�:�:��C��H�H�:�:�:r(rqrrrts r'r:z AND.__str__�s3�� �� � �:�:�� �:�:�:�;�;� ;�C� ?���r(N) r9rCrDrErNr6rFrr4rBr>r:rGrYr(r'rrms������������1�1�1��+�+��X�+���� ?�?�?�'�'�'�����H�H�Hr(rNc �� ���ddlm}��i�t|jt|jt |jt|j t|j t|j i}t|��|vr|t|��}||j�}t!|t"��r |jd}t%|���}|St!|t&��r't)�fd�t'j|��D���St!|t,��r't/�fd�t-j|��D���St!|t0��rt/�fd�|jD���}|St!|t2��rt)�fd�|jD���}|St!|t4��r|g}t7dt9|j��dzd ��D]J}t;|j|��D]2���fd �|jD��} |�t)| ����3�Kt/|�St!|t>��r}g}t7dt9|j��dzd ��D]J}t;|j|��D]2���fd �|jD��} |�t)| ����3�Kt/|�St!|t@��rGt%|jd���t%|jd���} } t)| | ��St!|tB��r�g}tE|j|jdd�|jd� ��D]I\} } t%| ���} t%| ���} |�t)| | �����Jt/|�St!|tF��r~t%|jd���} t%|jd���}t%|jd ���} t/t)| |��t)| | ����St!|tH��r>|j%|j&}}��'|d��}|�t%|j(|����St!|tR��r(��'|d��}|�t%|���StU|��S) a� Generates the Negation Normal Form of any boolean expression in terms of AND, OR, and Literal objects. Examples ======== >>> from sympy import Q, Eq >>> from sympy.assumptions.cnf import to_NNF >>> from sympy.abc import x, y >>> expr = Q.even(x) & ~Q.positive(x) >>> to_NNF(expr) (Literal(Q.even(x), False) & Literal(Q.positive(x), True)) Supported boolean objects are converted to corresponding predicates. >>> to_NNF(Eq(x, y)) Literal(Q.eq(x, y), False) If ``composite_map`` argument is given, ``to_NNF`` decomposes the specified predicate into a combination of primitive predicates. >>> cmap = {Q.nonpositive: Q.negative | Q.zero} >>> to_NNF(Q.nonpositive, cmap) (Literal(Q.negative, False) | Literal(Q.zero, False)) >>> to_NNF(Q.nonpositive(x), cmap) (Literal(Q.negative(x), False) | Literal(Q.zero(x), False)) r)�QNc�0��g|]}t|�����SrY��to_NNF�r\�x� composite_maps �r'r]zto_NNF.<locals>.<listcomp>�s#���I�I�I��F�1�m�,�,�I�I�Ir(c�0��g|]}t|�����SrYr�r�s �r'r]zto_NNF.<locals>.<listcomp>�s#���K�K�K�!�V�A�}�-�-�K�K�Kr(c�0��g|]}t|�����SrYr�r�s �r'r]zto_NNF.<locals>.<listcomp>�s#���@�@�@��F�1�m�,�,�@�@�@r(c�0��g|]}t|�����SrYr�r�s �r'r]zto_NNF.<locals>.<listcomp>�s#���?�?�?��6�!�]�+�+�?�?�?r(��c�Z��g|]'}|�vrt|���nt|�����(SrYr��r\rur��negs ��r'r]zto_NNF.<locals>.<listcomp>��M���.�.�.��89�C�x�x�6�!�]�3�3�3�3�V�A�}�E]�E]�.�.�.r(c�Z��g|]'}|�vrt|���nt|�����(SrYr�r�s ��r'r]zto_NNF.<locals>.<listcomp>�r�r()� fillvalue)+�sympy.assumptions.askr�r�eqr �ner �gtr �ltr �ger �ler2rrrr�rr� make_argsrrrrr�range�lenr�appendrrrrrr�function� arguments�getr4rr)r3r�r�� binrelpreds�predr.�tmp�cnfs�i�clause�L�R�a�b�Mr�newpredr�s ` @r'r�r��s�����:(�'�'�'�'�'���� ��q�t�R���r�1�4��Q�T�2�q�t�R���N�K� �D�z�z�[� � ��4��:�:�&���t�T�Y����$������i��l���S�-�(�(���t� ��$����K��I�I�I�I�b�l�4�6H�6H�I�I�I�J�J��$����M��K�K�K�K�s�}�T�7J�7J�K�K�K�L�L��$������@�@�@�@�d�i�@�@�@�A���t� ��$������?�?�?�?�T�Y�?�?�?�@���t� ��$��������q�#�d�i�.�.�1�,�a�0�0� )� )�A�#�D�I�q�1�1� )� )��.�.�.�.�.�#'�9�.�.�.��� � �B��K�(�(�(�(� )��D�z���$��������q�#�d�i�.�.�1�,�a�0�0� )� )�A�#�D�I�q�1�1� )� )��.�.�.�.�.�#'�9�.�.�.��� � �B��K�(�(�(�(� )��T� �{���$�� � ���d�i��l�M�2�2�F�4�9�Q�<��4W�4W�1���1�"�a�y�y���$� �#�#������ �4�9�Q�R�R�=�D�I�a�L�Q�Q�Q� #� #�D�A�q��q�-�(�(�A��q�-�(�(�A� �K�K��A�2�q� � � "� "� "� "��D�z���$����(� �4�9�Q�<�� /� /�� �4�9�Q�<�� /� /�� �4�9�Q�<�� /� /���2�q�b�!�9�9�b��A�h�h�'�'�'��$�(�)�)�?��]�D�N�d���#�#�D�$�/�/�� � ��-�'�-��.� �>�>� >��$� �"�"�2��#�#�D�$�/�/�� � ��'�=�1�1� 1� �4�=�=�r(c��t|ttf��s@t��}|�t |f����t |��St|t��rt jd�|jD���St|t��rt j d�|jD���SdS)z� Distributes AND over OR in the NNF expression. Returns the result( Conjunctive Normal Form of expression) as a CNF object. c�,�g|]}t|����SrY��distribute_AND_over_ORrds r'r]z*distribute_AND_over_OR.<locals>.<listcomp>s0��3�3�3� #�3�3�7�7�3�3�3r(c�,�g|]}t|����SrYr�rds r'r]z*distribute_AND_over_OR.<locals>.<listcomp> s0��4�4�4�!$�4�C�8�8�4�4�4r(N) rrr�set�add� frozenset�CNF�all_orrL�all_and)r3r�s r'r�r��s��� �d�S�"�I� &� &���e�e�� ��� �4�'�"�"�#�#�#��3�x�x���$����4��z�3�3�'+�z�3�3�3�4� 4��$����5��{�4�4�(,� �4�4�4�5� 5�5�5r(c���eZdZdZdd�Zd�Zd�Zd�Zd�Zd�Z e d ���Z d �Z d �Z d �Zd �Zd�Zd�Ze d���Ze d���Ze d���Ze d���ZdS)r�a Class to represent CNF of a Boolean expression. Consists of set of clauses, which themselves are stored as frozenset of Literal objects. Examples ======== >>> from sympy import Q >>> from sympy.assumptions.cnf import CNF >>> from sympy.abc import x >>> cnf = CNF.from_prop(Q.real(x) & ~Q.zero(x)) >>> cnf.clauses {frozenset({Literal(Q.zero(x), True)}), frozenset({Literal(Q.negative(x), False), Literal(Q.positive(x), False), Literal(Q.zero(x), False)})} Nc�4�|st��}||_dSr*�r��clauses�r-r�s r'rNz CNF.__init__ s��� ��e�e�G��� � � r(c�n�t�|��j}|�|��dSr*)r��to_CNFr�� add_clauses)r-�propr�s r'r�zCNF.add%s0���*�*�T�"�"�*�� ����!�!�!�!�!r(c�N�d�d�|jD����}|S)Nr�c�X�g|]'}dd�d�|D����zdz��(S)rmrnc�,�g|]}t|����SrYrp)r\r"s r'r]z*CNF.__str__.<locals>.<listcomp>.<listcomp>+s��:�:�:�C�s�3�x�x�:�:�:r(rq)rs�r\r�s r'r]zCNF.__str__.<locals>.<listcomp>+sM�� (� (� (���5�:�:�:�:�6�:�:�:�;�;� ;�S� @� (� (� (r()rsr�rts r'r:z CNF.__str__)s:�� �J�J� (� (��,� (� (� (� � ���r(c�:�|D]}|�|���|Sr*�r�)r-�props�ps r'�extendz CNF.extend0s'��� � �A� �H�H�Q�K�K�K�K�� r(c�D�tt|j����Sr*)r�r�r�r,s r'�copyzCNF.copy5s���3�t�|�$�$�%�%�%r(c�&�|xj|zc_dSr*)r�r�s r'r�zCNF.add_clauses8s�� � � ��� � � � r(c�D�|��}|�|��|Sr*r�)r$r��ress r'� from_propz CNF.from_prop;s!���c�e�e�� ���� � � �� r(c�:�|�|j��|Sr*)r�r�r<s r'�__iand__z CNF.__iand__As�� �����'�'�'�� r(c�T�t��}|jD]}|d�|D��z}�|S)Nc��h|] }|j�� SrYr+rds r'� <setcomp>z%CNF.all_predicates.<locals>.<setcomp>Hs��0�0�0�s�3�7�0�0�0r(r�)r-� predicates�cs r'�all_predicateszCNF.all_predicatesEs=���U�U� ��� 1� 1�A� �0�0�a�0�0�0� 0�J�J��r(c��t��}t|j|j��D]K\}}t|��}|�|��|�t |�����Lt |��Sr*)r�rr��updater�r�r�)r-�cnfr�r�r�r�s r'�_orzCNF._orKsm���%�%���D�L�#�+�6�6� (� (�D�A�q��a�&�&�C� �J�J�q�M�M�M� �K�K� �#��� '� '� '� '��7�|�|�r(c�^�|j�|j��}t|��Sr*)r��unionr��r-r�r�s r'�_andzCNF._andSs%���,�$�$�S�[�1�1���7�|�|�r(c���t|j��}d�|dD��}t|��}|dd�D]0}d�|D��}|�t|����}�1|S)Nc�0�h|]}t|f����SrY�r��r\r�s r'r�zCNF._not.<locals>.<setcomp>Ys$�� 1� 1� 1�1�i�!����� 1� 1� 1r(�����c�0�h|]}t|f����SrYr�r�s r'r�zCNF._not.<locals>.<setcomp>]s$��0�0�0�a��Q�B�5�!�!�0�0�0r()�listr�r�r�)r-�clss�ll�restr�s r'�_notzCNF._notWsy���D�L�!�!�� 1� 1��R�� 1� 1� 1�� ��W�W����"��I� � �D�0�0�4�0�0�0�A�����A�����B�B�� r(c���g}|jD],}�fd�|D��}|�t|����-t|��t ���S)Nc�:��g|]}|������SrYrZr[s �r'r]zCNF.rcall.<locals>.<listcomp>ds#���6�6�6��C�I�I�d�O�O�6�6�6r()r�r�rrr�)r-r3� clause_listr��litss ` r'r4z CNF.rcallase���� ��l� *� *�F�6�6�6�6�v�6�6�6�D� � � �r�4�y� )� )� )� )��K� ��%�d�+�+�+r(c�~�|d���}|dd�D]}|�|��}�|S�Nrr�)r�r��r$r�r�r�s r'r�z CNF.all_oris@�� ��G�L�L�N�N������H� � �D����d� � �A�A��r(c�~�|d���}|dd�D]}|�|��}�|Sr�)r�r�r�s r'r�z CNF.all_andps@�� ��G�L�L�N�N������H� � �D����t� � �A�A��r(c�`�ddlm}t||����}t|��}|S)Nr)�get_composite_predicates)�sympy.assumptions.factsr�r�r�)r$r3r�s r'r�z CNF.to_CNFws?��D�D�D�D�D�D��d�4�4�6�6�7�7��%�d�+�+��� r(c�>��d��t�fd�|jD���S)zm Converts CNF object to SymPy's boolean expression retaining the form of expression. c�F�|jrt|j��n|jSr*)r#rr")r.s r'�remove_literalz&CNF.CNF_to_cnf.<locals>.remove_literal�s��#&�:�:�3�s�w�<�<�<�3�7� :r(c3�B�K�|]}t�fd�|D���V��dS)c3�.�K�|]}�|��V��dSr*rY)r\r.r�s �r'� <genexpr>z+CNF.CNF_to_cnf.<locals>.<genexpr>.<genexpr>�s-�����@�@�#�.�.��-�-�@�@�@�@�@�@r(N)r)r\r�r�s �r'r�z!CNF.CNF_to_cnf.<locals>.<genexpr>�s=�����\�\�f�R�@�@�@�@��@�@�@�A�\�\�\�\�\�\r()rr�)r$r�r�s @r'� CNF_to_cnfzCNF.CNF_to_cnf~s8���  ;� ;� ;��\�\�\�\�PS�P[�\�\�\�]�]r(r*)r9rCrDrErNr�r:r�r�r�� classmethodr�r�r�r�r�r�r4r�r�r�r�rYr(r'r�r�sc��������"���� "�"�"������� &�&�&� � � �����[�� ������ ���������,�,�,�����[�� ����[�� ����[�� �^�^��[�^�^�^r(r�c�j�eZdZdZd d�Zd�Zed���Zed���Zd�Z d�Z d �Z d �Z d �Z dS) � EncodedCNFz0 Class for encoding the CNF expression. Nc�~�|s|sg}i}||_||_t|�����|_dSr*)�data�encodingr��keys�_symbols)r-rrs r'rNzEncodedCNF.__init__�sD��� �H� ��D��H��� � �� ��X�]�]�_�_�-�-�� � � r(c ���t|������_t�j��}t t �jt d|dz�������_�fd�|jD���_ dS)Nr�c�:��g|]}��|����SrY��encode�r\r�r-s �r'r]z'EncodedCNF.from_cnf.<locals>.<listcomp>�s%���C�C�C�V�T�[�[��(�(�C�C�Cr() r�r�rr��dict�zipr�rr�r)r-r��ns` r'�from_cnfzEncodedCNF.from_cnf�su����S�/�/�1�1�2�2�� � �� � � ���S����a��Q����@�@�A�A�� �C�C�C�C�s�{�C�C�C�� � � r(c��|jSr*)rr,s r'�symbolszEncodedCNF.symbols�s ���}�r(c�L�tdt|j��dz��S�Nr�)r�r�rr,s r'� variableszEncodedCNF.variables�s!���Q��D�M�*�*�Q�.�/�/�/r(c�h�d�|jD��}t|t|j����S)Nc�,�g|]}t|����SrY)r�r�s r'r]z#EncodedCNF.copy.<locals>.<listcomp>�s��8�8�8�F�C��K�K�8�8�8r()rrr r)r-�new_datas r'r�zEncodedCNF.copy�s1��8�8�d�i�8�8�8���(�D���$7�$7�8�8�8r(c�d�t�|��}|�|��dSr*)r�r�� add_from_cnf)r-r�r�s r'�add_propzEncodedCNF.add_prop�s-���m�m�D�!�!�� ���#�����r(c�N���fd�|jD��}�xj|z c_dS)Nc�:��g|]}��|����SrYr r s �r'r]z+EncodedCNF.add_from_cnf.<locals>.<listcomp>�s%���A�A�A�6�4�;�;�v�&�&�A�A�Ar()r�rr�s` r'rzEncodedCNF.add_from_cnf�s2���A�A�A�A�S�[�A�A�A�� � � �W�� � � � r(c���|j}|j�|d��}|�=t|j��}|j�|��|dzx}|j|<|jr| S|Sr)r"rr�r�rr�r#)r-r.�literal�valuers r'� encode_argzEncodedCNF.encode_arg�su���'��� �!�!�'�4�0�0�� �=��D�M�"�"�A� �M� � �� )� )� )�-.��U� 2�E�D�M�'�*� �:� ��6�M��Lr(c� ���fd�|D��S)Nc�h��h|].}|jtjks��|��nd��/S)r)r"r�falser )r\r.r-s �r'r�z$EncodedCNF.encode.<locals>.<setcomp>�s8���X�X�X�#�C�G�q�w�,>�,>�����$�$�$�A�X�X�Xr(rY)r-r�s` r'r zEncodedCNF.encode�s���X�X�X�X�QW�X�X�X�Xr()NN)r9rCrDrErNrrFrrr�rrr r rYr(r'rr�s���������.�.�.�.�D�D�D� ����X���0�0��X�0�9�9�9������� � � �Y�Y�Y�Y�Yr(rr*)#rE� itertoolsrrr�sympy.assumptions.assumerr�sympy.core.relationalrr r r r r �sympy.core.singletonr�sympy.logic.boolalgrrrrrrrrrrrrrr�r�r�rrYr(r'�<module>r)s����� 9�8�8�8�8�8�8�8�8�8�@�@�@�@�@�@�@�@�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�"�"�"�"�"�"�2�2�2�2�2�2�2�2�2�2�2�2�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�J�;�;�;�;�;�;�;�;�|��������@��������@j�j�j�j�Z5�5�5�(y^�y^�y^�y^�y^�y^�y^�y^�x3Y�3Y�3Y�3Y�3Y�3Y�3Y�3Y�3Y�3Yr(
Memory