Ë
    täiÝ0  ã                   ó  — d Z ddl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 ddlmZ ddlmZmZmZmZ ddlmZmZmZmZmZmZ  G d„ d	«      Z G d
„ d«      Z G d„ d«      Zdd„Zd„ Z  G d„ d«      Z! G d„ d«      Z"y)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                   óV   ‡ — e Zd ZdZd	ˆ fd„	Zed„ «       Zd„ Zd„ Zd„ Z	e	Z
d„ Zd„ Zˆ xZ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)
    c                 óÊ   •— t        |t        «      r|j                  d   }d}n"t        |t        t        t
        f«      r|r| S |S t        ‰| �  | «      }||_        ||_	        |S )Nr   T)
Ú
isinstancer   ÚargsÚANDÚORr   ÚsuperÚ__new__ÚlitÚis_Not)Úclsr"   r#   ÚobjÚ	__class__s       €úd/Volumes/fast/ai/experiments/MLX_z-image/.venv/lib/python3.12/site-packages/sympy/assumptions/cnf.pyr!   zLiteral.__new__&   s`   ø€ Ü�cœ3ÔØ—(‘(˜1‘+ˆCØ‰FÜ˜œc¤2¤wÐ/Ô0Ù!�C�4Ð* sÐ*Ü‰g‰o˜cÓ"ˆØˆŒØˆŒ
Øˆ
ó    c                 ó   — | j                   S ©N)r"   ©Úselfs    r'   ÚargzLiteral.arg1   s   € à�x‰xˆr(   c                 ó¾   — t        | j                  «      r| j                  |«      }n| j                  j                  |«      } t        | «      || j                  «      S r*   )Úcallabler"   ÚapplyÚtyper#   )r,   Úexprr"   s      r'   ÚrcallzLiteral.rcall5   sD   € Ü�D—H‘HÔØ—(‘(˜4“.‰Cà—(‘(—.‘. Ó&ˆCØŒt�D‹z˜#˜tŸ{™{Ó+Ð+r(   c                 óH   — | j                    }t        | j                  |«      S r*   )r#   r   r"   )r,   r#   s     r'   Ú
__invert__zLiteral.__invert__<   s   € Ø—[‘[�ˆÜ�t—x‘x Ó(Ð(r(   c                 óv   — dj                  t        | «      j                  | j                  | j                  «      S )Nz
{}({}, {}))Úformatr1   Ú__name__r"   r#   r+   s    r'   Ú__str__zLiteral.__str__@   s)   € Ø×"Ñ"¤4¨£:×#6Ñ#6¸¿¹À$Ç+Á+ÓNÐNr(   c                 ój   — | j                   |j                   k(  xr | j                  |j                  k(  S r*   )r-   r#   ©r,   Úothers     r'   Ú__eq__zLiteral.__eq__E   s'   € Ø�x‰x˜5Ÿ9™9Ñ$ÒD¨¯©¸¿¹Ñ)DÐDr(   c                 óp   — t        t        | «      j                  | j                  | j                  f«      }|S r*   )Úhashr1   r8   r-   r#   )r,   Úhs     r'   Ú__hash__zLiteral.__hash__H   s*   € Ü”$�t“*×%Ñ% t§x¡x°·±Ð=Ó>ˆØˆr(   )F)r8   Ú
__module__Ú__qualname__Ú__doc__r!   Úpropertyr-   r3   r5   r9   Ú__repr__r=   rA   Ú__classcell__)r&   s   @r'   r   r      sC   ø„ ñõ,	ð ñó ðò,ò)òOð €HòEör(   r   c                   óH   — e Zd ZdZd„ Zed„ «       Zd„ Zd„ Zd„ Z	d„ Z
d„ ZeZy	)
r   z+
    A low-level implementation for Or
    c                 ó   — || _         y r*   ©Ú_args©r,   r   s     r'   Ú__init__zOR.__init__Q   ó	   € Øˆ�
r(   c                 ó8   — t        | j                  t        ¬«      S ©N)Úkey©ÚsortedrK   Ústrr+   s    r'   r   zOR.argsT   ó   € ä�d—j‘j¤cÔ*Ð*r(   c                 óv   —  t        | «      | j                  D �cg c]  }|j                  |«      ‘Œ c}Ž S c c}w r*   ©r1   rK   r3   ©r,   r2   r-   s      r'   r3   zOR.rcallX   óA   € ØŒt�D‹zØ'+§z¢zóÙ'1 ð  ŸI™I d�OØ'1ñð ð 	ùò ó   š6c                 óN   — t        | j                  D �cg c]  }| ‘Œ c}Ž S c c}w r*   )r   rK   ©r,   r-   s     r'   r5   zOR.__invert__]   s%   € Ü T§Z¢ZÓ0¡Z˜c�c’T ZÑ0Ð1Ð1ùÒ0ó   ”
"c                 ól   — t        t        | «      j                  ft        | j                  «      z   «      S r*   ©r?   r1   r8   Útupler   r+   s    r'   rA   zOR.__hash__`   ó(   € Ü”T˜$“Z×(Ñ(Ð*¬U°4·9±9Ó-=Ñ=Ó>Ð>r(   c                 ó4   — | j                   |j                   k(  S r*   ©r   r;   s     r'   r=   z	OR.__eq__c   ó   € Ø�y‰y˜EŸJ™JÑ&Ð&r(   c           	      ó€   — ddj                  | j                  D �cg c]  }t        |«      ‘Œ c}«      z   dz   }|S c c}w )NÚ(ú | Ú)©Újoinr   rT   ©r,   r-   Úss      r'   r9   z
OR.__str__f   s;   € Ø�%—*‘*°$·)²)Ó<±)¨3œc #�h°)Ñ<Ó=Ñ=ÀÑCˆØˆùò =ó   ›;
N)r8   rB   rC   rD   rM   rE   r   r3   r5   rA   r=   r9   rF   © r(   r'   r   r   M   s@   „ ñòð ñ+ó ð+òò
2ò?ò'òð �Hr(   r   c                   óH   — e Zd ZdZd„ Zd„ Zed„ «       Zd„ Zd„ Z	d„ Z
d„ ZeZy	)
r   z,
    A low-level implementation for And
    c                 ó   — || _         y r*   rJ   rL   s     r'   rM   zAND.__init__q   rN   r(   c                 óN   — t        | j                  D �cg c]  }| ‘Œ c}Ž S c c}w r*   )r   rK   r\   s     r'   r5   zAND.__invert__t   s%   € Ü D§J¢JÓ/¡J˜S�S’D JÑ/Ð0Ð0ùÒ/r]   c                 ó8   — t        | j                  t        ¬«      S rP   rR   r+   s    r'   r   zAND.argsw   rU   r(   c                 óv   —  t        | «      | j                  D �cg c]  }|j                  |«      ‘Œ c}Ž S c c}w r*   rW   rX   s      r'   r3   z	AND.rcall{   rY   rZ   c                 ól   — t        t        | «      j                  ft        | j                  «      z   «      S r*   r_   r+   s    r'   rA   zAND.__hash__€   ra   r(   c                 ó4   — | j                   |j                   k(  S r*   rc   r;   s     r'   r=   z
AND.__eq__ƒ   rd   r(   c           	      ó€   — ddj                  | j                  D �cg c]  }t        |«      ‘Œ c}«      z   dz   }|S c c}w )Nrf   ú & rh   ri   rk   s      r'   r9   zAND.__str__†   s;   € Ø�—
‘
°·	²	Ó:±	¨œC �H°	Ñ:Ó;Ñ;¸CÑ?ˆØˆùò ;rm   N)r8   rB   rC   rD   rM   r5   rE   r   r3   rA   r=   r9   rF   rn   r(   r'   r   r   m   s@   „ ñòò1ð ñ+ó ð+òò
?ò'òð �Hr(   r   Nc                 ó.
  — ddl m} |€i }t        |j                  t        |j
                  t        |j                  t        |j                  t        |j                  t        |j                  i}t        | «      |v r|t        | «         } || j                  Ž } t!        | t"        «      r| j                  d   }t%        ||«      }| S t!        | t&        «      r3t)        t'        j*                  | «      D �cg c]  }t%        ||«      ‘Œ c}Ž S t!        | t,        «      r3t/        t-        j*                  | «      D �cg c]  }t%        ||«      ‘Œ c}Ž S t!        | t0        «      r-t/        | j                  D �cg c]  }t%        ||«      ‘Œ c}Ž }| S t!        | t2        «      r-t)        | j                  D �cg c]  }t%        ||«      ‘Œ c}Ž }| S t!        | t4        «      r˜g }t7        dt9        | j                  «      dz   d«      D ]h  }	t;        | j                  |	«      D ]M  }
| j                  D �cg c]  }||
v rt%        ||«       nt%        ||«      ‘Œ! }}|j=                  t)        |Ž «       ŒO Œj t/        |Ž S t!        | t>        «      r™g }t7        dt9        | j                  «      dz   d«      D ]h  }	t;        | j                  |	«      D ]M  }
| j                  D �cg c]  }||
v rt%        ||«       nt%        ||«      ‘Œ! }}|j=                  t)        |Ž «       ŒO Œj t/        |Ž  S t!        | t@        «      r?t%        | j                  d   |«      t%        | j                  d   |«      }}t)        | |«      S t!        | tB        «      rxg }tE        | j                  | j                  dd | j                  d   ¬«      D ]9  \  }}t%        ||«      }t%        ||«      }|j=                  t)        | |«      «       Œ; t/        |Ž S t!        | tF        «      rlt%        | j                  d   |«      }t%        | j                  d   |«      }t%        | j                  d   |«      }t/        t)        | |«      t)        ||«      «      S t!        | tH        «      rE| jJ                  | jL                  }}|jO                  |d«      }|�t%         |jP                  |Ž |«      S t!        | tR        «      r |jO                  | d«      }|�t%        ||«      S tU        | «      S c c}w c c}w c c}w c c}w c c}w c c}w )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   )ÚQNé   é   )Ú	fillvalue)+Úsympy.assumptions.askry   r   Úeqr	   Úner
   Úgtr   Últr   Úger   Úler1   r   r   r   Úto_NNFr   r   Ú	make_argsr   r   r   r   r   ÚrangeÚlenr   Úappendr   r   r   r   r   r   ÚfunctionÚ	argumentsÚgetr3   r   r   )r2   Úcomposite_mapry   ÚbinrelpredsÚpredr-   ÚtmpÚxÚcnfsÚiÚnegrl   ÚclauseÚLÚRÚaÚbÚMr   Únewpreds                       r'   r„   r„   �   sq  € õ: (àÐØˆô �q—t‘tœR §¡¤r¨1¯4©4´°Q·T±T¼2¸q¿t¹tÄRÈÏÉÐN€KÜˆDƒz�[Ñ Øœ4 ›:Ñ&ˆÙ�T—Y‘YÐˆä�$œÔØ�i‰i˜‰lˆÜ�S˜-Ó(ˆØˆtˆä�$œÔÜ´b·l±lÀ4Ô6HÓIÑ6H°”F˜1˜mÕ,Ð6HÑIÐJÐJä�$œÔÜ´s·}±}ÀTÔ7JÓKÑ7J°!”V˜A˜}Õ-Ð7JÑKÐLÐLä�$œÔÜ°d·i²iÓ@±i°”F˜1˜mÕ,°iÑ@ÐAˆØˆtˆä�$œÔÜ°T·Y²YÓ?±Y°”6˜!˜]Õ+°YÑ?Ð@ˆØˆtˆä�$œÔØˆÜ�qœ#˜dŸi™i›.¨1Ñ,¨aÖ0ˆAÜ# D§I¡I¨qÖ1�à#'§9¢9ó.Ù#,˜að 89¸C±xœ6 ! ]Ó3Ñ3ÄVÈAÈ}ÓE]Ñ]Ø#,ð ð .à—‘œB ˜KÕ(ñ 2ð 1ô
 �DˆzÐä�$œÔØˆÜ�qœ#˜dŸi™i›.¨1Ñ,¨aÖ0ˆAÜ# D§I¡I¨qÖ1�à#'§9¢9ó.Ù#,˜að 89¸C±xœ6 ! ]Ó3Ñ3ÄVÈAÈ}ÓE]Ñ]Ø#,ð ð .à—‘œB ˜KÕ(ñ 2ð 1ô
 �T�
ˆ{Ðä�$œÔ Ü�d—i‘i ‘l MÓ2´F¸4¿9¹9ÀQ¹<ÈÓ4Wˆ1ˆÜ�1�"�a‹yÐä�$œ
Ô#ØˆÜ §	¡	¨4¯9©9°Q°R¨=ÀDÇIÁIÈaÁL×Q‰DˆAˆqÜ�q˜-Ó(ˆAÜ�q˜-Ó(ˆAØ�K‰Kœ˜A˜2˜q›	Õ"ð Rô �DˆzÐä�$œÔÜ�4—9‘9˜Q‘< Ó/ˆÜ�4—9‘9˜Q‘< Ó/ˆÜ�4—9‘9˜Q‘< Ó/ˆÜ”2�q�b˜!“9œb  A›hÓ'Ð'ä�$Ô(Ô)Ø—]‘] D§N¡NˆdˆØ×#Ñ# D¨$Ó/ˆØÐÜ˜-˜'Ÿ-™-¨Ð.°Ó>Ð>ä�$œ	Ô"Ø×#Ñ# D¨$Ó/ˆØÐÜ˜' =Ó1Ð1ä�4‹=Ðùòy Jùò Lùò Aùò @ùò.ùò.s$   Ã1S9Ä4S>Å.TÆ+TÈ$$TË$Tc                 ó°  — t        | t        t        f«      s0t        «       }|j	                  t        | f«      «       t        |«      S t        | t        «      r3t        j                  | j                  D �cg c]  }t        |«      ‘Œ c}Ž S t        | t        «      r3t        j                  | j                  D �cg c]  }t        |«      ‘Œ c}Ž S yc c}w c c}w )zŒ
    Distributes AND over OR in the NNF expression.
    Returns the result( Conjunctive Normal Form of expression)
    as a CNF object.
    N)r   r   r   ÚsetÚaddÚ	frozensetÚCNFÚall_orrK   Údistribute_AND_over_ORÚall_and)r2   r�   r-   s      r'   r¡   r¡   ú   sÄ   € ô �dœS¤"˜IÔ&Ü‹eˆØ�‰”	˜4˜'Ó"Ô#Ü�3‹xˆä�$œÔÜ�z‰zØ'+§z¢zó3Ù'1 ô 3°3Õ7Ø'1ñ3ð 4ð 	4ô �$œÔÜ�{‰{Ø(,¯
ª
ó4Ù(2 ô 4°CÕ8Ø(2ñ4ð 5ð 	5ð ùò3ùò4s   Á4CÂ7Cc                   óª   — e Zd ZdZdd„Zd„ Zd„ Zd„ Zd„ Zd„ Z	e
d	„ «       Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Ze
d„ «       Ze
d„ «       Ze
d„ «       Ze
d„ «       Zy)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                 ó*   — |s
t        «       }|| _        y r*   )rœ   Úclauses©r,   r¥   s     r'   rM   zCNF.__init__   s   € ÙÜ“eˆGØˆ�r(   c                 ód   — t         j                  |«      j                  }| j                  |«       y r*   )rŸ   Úto_CNFr¥   Úadd_clauses)r,   Úpropr¥   s      r'   r�   zCNF.add%  s$   € Ü—*‘*˜TÓ"×*Ñ*ˆØ×Ñ˜Õ!r(   c                 óÊ   — dj                  | j                  D ��cg c]0  }ddj                  |D �cg c]  }t        |«      ‘Œ c}«      z   dz   ‘Œ2 c}}«      }|S c c}w c c}}w )Nrw   rf   rg   rh   )rj   r¥   rT   )r,   r”   r"   rl   s       r'   r9   zCNF.__str__)  sf   € Ø�J‰JàŸ,š,ô(Ù&�ð �5—:‘:±6Ó:±6¨Cœs 3�x°6Ñ:Ó;Ñ;¸SÓ@Ø&ò(ó
ˆð ˆùò ;ùó (s   ›A
°AÁA
ÁA
c                 ó6   — |D ]  }| j                  |«       Œ | S r*   ©r�   )r,   ÚpropsÚps      r'   Úextendz
CNF.extend0  s   € ÛˆAØ�H‰H�Q�Kð àˆr(   c                 ó>   — t        t        | j                  «      «      S r*   )rŸ   rœ   r¥   r+   s    r'   ÚcopyzCNF.copy5  s   € Ü”3�t—|‘|Ó$Ó%Ð%r(   c                 ó.   — | xj                   |z  c_         y r*   )r¥   r¦   s     r'   r©   zCNF.add_clauses8  s   € Ø�Š˜ÑŽr(   c                 ó6   —  | «       }|j                  |«       |S r*   r­   )r$   rª   Úress      r'   Ú	from_propzCNF.from_prop;  s   € á‹eˆØ�‰�ŒØˆ
r(   c                 ó<   — | j                  |j                  «       | S r*   )r©   r¥   r;   s     r'   Ú__iand__zCNF.__iand__A  s   € Ø×Ñ˜Ÿ™Ô'Øˆr(   c                 ó€   — t        «       }| j                  D ]  }||D �ch c]  }|j                  ’Œ c}z  }Œ! |S c c}w r*   )rœ   r¥   r"   )r,   Ú
predicatesÚcr-   s       r'   Úall_predicateszCNF.all_predicatesE  s?   € Ü“Uˆ
Ø—”ˆAØ©aÓ0©a s˜3Ÿ7›7¨aÑ0Ñ0‰Jð àÐùò 1s   Ÿ;c                 óè   — t        «       }t        | j                  |j                  «      D ];  \  }}t        |«      }|j                  |«       |j	                  t        |«      «       Œ= t        |«      S r*   )rœ   r   r¥   Úupdater�   rž   rŸ   )r,   Úcnfr¥   r—   r˜   r�   s         r'   Ú_orzCNF._orK  sV   € Ü“%ˆÜ˜DŸL™L¨#¯+©+Ö6‰DˆAˆqÜ�a“&ˆCØ�J‰J�qŒMØ�K‰Kœ	 #›Õ'ð 7ô �7‹|Ðr(   c                 ób   — | j                   j                  |j                   «      }t        |«      S r*   )r¥   ÚunionrŸ   )r,   r¿   r¥   s      r'   Ú_andzCNF._andS  s$   € Ø—,‘,×$Ñ$ S§[¡[Ó1ˆÜ�7‹|Ðr(   c                 ó  — t        | j                  «      }|d   D �ch c]  }t        | f«      ’Œ }}t        |«      }|d d D ]6  }|D �ch c]  }t        | f«      ’Œ }}|j	                  t        |«      «      }Œ8 |S c c}w c c}w )Néÿÿÿÿ)Úlistr¥   rž   rŸ   rÀ   )r,   Úclssr�   ÚllÚrestr¯   s         r'   Ú_notzCNF._notW  s‰   € Ü�D—L‘LÓ!ˆØ(,¨RªÓ1© 1Œi˜!˜˜Õ¨ˆÐ1Ü�‹Wˆà˜˜"“IˆDÙ+/Ó0©4 a”˜Q˜B˜5Õ!¨4ˆAÐ0Ø—‘œ˜A›“‰Bð ð ˆ	ùò 2ùò 1s   �A>Á
Bc                 óÂ   — g }| j                   D ]7  }|D �cg c]  }|j                  |«      ‘Œ }}|j                  t        |Ž «       Œ9 t	        |Ž }t        |«      S c c}w r*   )r¥   r3   rˆ   r   r   r¡   )r,   r2   Úclause_listr”   r-   Úlitss         r'   r3   z	CNF.rcalla  s_   € ØˆØ—l”lˆFÙ/5Ó6©v¨�C—I‘I˜d•O¨vˆDÐ6Ø×Ñœr 4˜yÕ)ð #ô �KÐ ˆÜ% dÓ+Ð+ùò 7s   –Ac                 ób   — |d   j                  «       }|dd  D ]  }|j                  |«      }Œ |S ©Nr   rz   )r²   rÀ   ©r$   r‘   r˜   rÉ   s       r'   r    z
CNF.all_ori  s3   € à�‰G�L‰L‹NˆØ˜˜“HˆDØ—‘�d“‰Að àˆr(   c                 ób   — |d   j                  «       }|dd  D ]  }|j                  |«      }Œ |S rÏ   )r²   rÃ   rÐ   s       r'   r¢   zCNF.all_andp  s3   € à�‰G�L‰L‹NˆØ˜˜“HˆDØ—‘�t“‰Að àˆr(   c                 óJ   — ddl m} t        | |«       «      }t        |«      }|S )Nr   )Úget_composite_predicates)Úsympy.assumptions.factsrÓ   r„   r¡   )r$   r2   rÓ   s      r'   r¨   z
CNF.to_CNFw  s$   € åDÜ�dÑ4Ó6Ó7ˆÜ% dÓ+ˆØˆr(   c                 ó@   ‡— d„ Št        ˆfd„|j                  D «       Ž S )zm
        Converts CNF object to SymPy's boolean expression
        retaining the form of expression.
        c                 ó\   — | j                   rt        | j                  «      S | j                  S r*   )r#   r   r"   )r-   s    r'   Úremove_literalz&CNF.CNF_to_cnf.<locals>.remove_literal„  s   € Ø#&§:¢:”3�s—w‘w“<Ð:°3·7±7Ð:r(   c              3   ó@   •K  — | ]  }t        ˆfd „|D «       Ž –— Œ y­w)c              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wr*   rn   )Ú.0r-   r×   s     €r'   Ú	<genexpr>z+CNF.CNF_to_cnf.<locals>.<genexpr>.<genexpr>‡  s   øè ø€ Ð@¹°#™.¨×-¹ùs   ƒN)r   )rÚ   r”   r×   s     €r'   rÛ   z!CNF.CNF_to_cnf.<locals>.<genexpr>‡  s   øè ø€ Ð\ÑP[Àf”RÓ@¹Ó@ÔAÑP[ùs   ƒ)r   r¥   )r$   r¿   r×   s     @r'   Ú
CNF_to_cnfzCNF.CNF_to_cnf~  s"   ø€ ò	;ô Ó\ÐPS×P[ÒP[Ó\Ð]Ð]r(   r*   )r8   rB   rC   rD   rM   r�   r9   r°   r²   r©   Úclassmethodr¶   r¸   r¼   rÀ   rÃ   rÊ   r3   r    r¢   r¨   rÜ   rn   r(   r'   rŸ   rŸ     s©   „ ñó"ò
"òòò
&ò ð ñó ðò
òòòòò,ð ñó ðð ñó ðð ñó ðð ñ^ó ñ^r(   rŸ   c                   ó\   — e Zd ZdZdd„Zd„ Zed„ «       Zed„ «       Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zy)Ú
EncodedCNFz0
    Class for encoding the CNF expression.
    Nc                 ól   — |s|sg }i }|| _         || _        t        |j                  «       «      | _        y r*   )ÚdataÚencodingrÆ   ÚkeysÚ_symbols)r,   rá   râ   s      r'   rM   zEncodedCNF.__init__Ž  s1   € Ù™HØˆDØˆHØˆŒ	Ø ˆŒÜ˜XŸ]™]›_Ó-ˆ�r(   c           
      ó2  — t        |j                  «       «      | _        t        | j                  «      }t	        t        | j                  t        d|dz   «      «      «      | _        |j                  D �cg c]  }| j                  |«      ‘Œ c}| _
        y c c}w ©Nrz   )rÆ   r¼   rä   r‡   ÚdictÚzipr†   râ   r¥   Úencoderá   )r,   r¿   Únr”   s       r'   Úfrom_cnfzEncodedCNF.from_cnf–  sl   € Ü˜S×/Ñ/Ó1Ó2ˆŒÜ�—‘ÓˆÜœS §¡´°a¸¸Q¹³Ó@ÓAˆŒØ7:·{²{ÓC±{¨V�T—[‘[ Õ(°{ÑCˆ�	ùÒCs   Á3Bc                 ó   — | j                   S r*   )rä   r+   s    r'   ÚsymbolszEncodedCNF.symbolsœ  s   € à�}‰}Ðr(   c                 óF   — t        dt        | j                  «      dz   «      S ræ   )r†   r‡   rä   r+   s    r'   Ú	variableszEncodedCNF.variables   s   € ä�Qœ˜DŸM™MÓ*¨QÑ.Ó/Ð/r(   c                 óŽ   — | j                   D �cg c]  }t        |«      ‘Œ }}t        |t        | j                  «      «      S c c}w r*   )rá   rœ   rß   rç   râ   )r,   r”   Únew_datas      r'   r²   zEncodedCNF.copy¤  s9   € Ø.2¯iªiÓ8©i F”C˜•K¨iˆÐ8Ü˜(¤D¨¯©Ó$7Ó8Ð8ùò 9s   �Ac                 óP   — t         j                  |«      }| j                  |«       y r*   )rŸ   r¶   Úadd_from_cnf)r,   rª   r¿   s      r'   Úadd_propzEncodedCNF.add_prop¨  s   € Ü�m‰m˜DÓ!ˆØ×Ñ˜#Õr(   c                 óˆ   — |j                   D �cg c]  }| j                  |«      ‘Œ }}| xj                  |z  c_        y c c}w r*   )r¥   ré   rá   )r,   r¿   r”   r¥   s       r'   ró   zEncodedCNF.add_from_cnf¬  s7   € Ø58·[²[ÓA±[¨6�4—;‘;˜vÕ&°[ˆÐAØ�	Š	�WÑŽ	ùò Bs   �?c                 ó   — |j                   }| j                  j                  |d «      }|€Dt        | j                  «      }| j                  j                  |«       |dz   x}| j                  |<   |j                  r| S |S ræ   )r"   râ   r‹   r‡   rä   rˆ   r#   )r,   r-   ÚliteralÚvaluerê   s        r'   Ú
encode_argzEncodedCNF.encode_arg°  sp   € Ø—'‘'ˆØ—‘×!Ñ! '¨4Ó0ˆØˆ=Ü�D—M‘MÓ"ˆAØ�M‰M× Ñ  Ô)Ø-.°©UÐ2ˆE�D—M‘M 'Ñ*Ø�:Š:Ø�6ˆMàˆLr(   c                 óˆ   — |D �ch c]2  }|j                   t        j                  k(  s| j                  |«      nd’Œ4 c}S c c}w )Nr   )r"   r   Úfalserù   )r,   r”   r-   s      r'   ré   zEncodedCNF.encode¼  s9   € ÙQWÓXÑQWÈ#¨C¯G©G´q·w±wÒ,>�—‘ Ô$ÀAÑEÐQWÑXÐXùÒXs   …7?)NN)r8   rB   rC   rD   rM   rë   rE   rí   rï   r²   rô   ró   rù   ré   rn   r(   r'   rß   rß   Š  sT   „ ñó.òDð ñó ðð ñ0ó ð0ò9òòò
óYr(   rß   r*   )#rD   Ú	itertoolsr   r   r   Úsympy.assumptions.assumer   r   Úsympy.core.relationalr   r	   r
   r   r   r   Úsympy.core.singletonr   Úsympy.logic.boolalgr   r   r   r   r   r   r   r   r   r   r   r   r   r„   r¡   rŸ   rß   rn   r(   r'   Ú<module>r     sr   ðñ÷ 9Ñ 8ß @ß 8× 8Ý "ß 2Ó 2ß J× J÷;ñ ;÷|ñ ÷@ñ ó@jòZ5÷(y^ñ y^÷x3Yò 3Yr(   