a
     ˜ëjÓÉ  ã                   @   sD  d dl Z d dlmZ d dlmZ d dlmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlm Z  G dd„ deƒZ!G dd	„ d	eƒZ"G d
d„ dƒZ#G dd„ de#eƒZ$dd„ Z%G dd„ de#eƒZ&G dd„ de&eƒZ'G dd„ de&eƒZ(G dd„ de'eƒZ)G dd„ de&eƒZ*G dd„ de#eƒZ+G dd„ de#eƒZ,G dd„ de#eƒZ-G d d!„ d!e#eƒZ.G d"d#„ d#e.eƒZ/G d$d%„ d%e/eƒZ0G d&d'„ d'e.eƒZ1G d(d)„ d)e/ƒZ2G d*d+„ d+e#e
ƒZ3d,d-„ Z4G d.d/„ d/e5e#eƒZ6G d0d1„ d1e7ƒZ8g fd2d3„Z9G d4d5„ d5ƒZ:d6d7„ Z;d8d9„ Z<e=d:k�r@e;ƒ  dS );é    N)Úreduce)Úchain)ÚAPPÚAbstractVariableExpressionÚAllExpressionÚAndExpressionÚApplicationExpressionÚBinaryExpressionÚBooleanExpressionÚConstantExpressionÚEqualityExpressionÚEventVariableExpressionÚExistsExpressionÚ
ExpressionÚFunctionVariableExpressionÚImpExpressionÚIndividualVariableExpressionÚLambdaExpressionÚLogicParserÚNegatedExpressionÚOrExpressionÚTokensÚVariableÚis_eventvarÚ
is_funcvarÚ	is_indvarÚunique_variable)Úin_idlec                   @   sJ   e Zd ZdZdZdZdZdZdZeeeegZ	e
je	 Ze
jeg e	 ZdS )Ú	DrtTokensÚDRSú+ZPROú[ú]ú:N)Ú__name__Ú
__module__Ú__qualname__r   ÚDRS_CONCÚPRONOUNÚOPEN_BRACKETÚCLOSE_BRACKETÚCOLONZPUNCTr   ÚSYMBOLSÚTOKENS© r.   r.   úK/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/nltk/sem/drt.pyr   +   s   
r   c                   @   sˆ   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zd S )!Ú	DrtParserz$A lambda calculus expression parser.c                 C   s’   t  | ¡ tdd„ tjD ƒdd„ tjD ƒ tdfg dd„ tjtj	 D ƒ tj
dfg tjdfg dd„ tjD ƒ d	d„ tjD ƒ d
g ƒ| _d S )Nc                 S   s   g | ]}|d f‘qS ©é   r.   ©Ú.0Úxr.   r.   r/   Ú
<listcomp>A   ó    z&DrtParser.__init__.<locals>.<listcomp>c                 S   s   g | ]}|d f‘qS )é   r.   r3   r.   r.   r/   r6   B   r7   é   c                 S   s   g | ]}|d f‘qS )é   r.   r3   r.   r.   r/   r6   D   r7   é   é   c                 S   s   g | ]}|d f‘qS )é   r.   r3   r.   r.   r/   r6   G   r7   c                 S   s   g | ]}|d f‘qS )é   r.   r3   r.   r.   r/   r6   H   r7   )Né	   )r   Ú__init__Údictr   ÚLAMBDA_LISTÚNOT_LISTr   ZEQ_LISTr   ZNEQ_LISTr+   r'   ÚOR_LISTÚIMP_LISTÚoperator_precedence©Úselfr.   r.   r/   r@   =   s(    
ÿþý
ü
ûúùøÿzDrtParser.__init__c                 C   s   t jS )z#This method exists to be overridden)r   r,   rG   r.   r.   r/   Úget_all_symbolsL   s    zDrtParser.get_all_symbolsc                 C   s
   |t jvS ©N)r   r-   )rH   Útokr.   r.   r/   Ú
isvariableP   s    zDrtParser.isvariablec                 C   sÐ   |t jv r|  ||¡S |t jv r,|  ||¡S |t jkrj|  d¡r\|  d¡t jkr\|  	||¡S |  
||¡S nb| ¡ t jkr�|  t j¡ |  	||¡S |  |¡rÌ|  d¡rÀ|  d¡t jkrÀ|  ||¡S |  ||¡S dS )zgThis method is intended to be overridden for logics that
        use different operators or expressionsr   N)r   rC   Zhandle_negationrB   Zhandle_lambdaÚOPENÚinRangeÚtokenr)   Ú
handle_DRSÚhandle_openÚupperr   ÚassertNextTokenrL   r+   Úhandle_propZhandle_variable)rH   rK   Úcontextr.   r.   r/   ÚhandleS   s    



zDrtParser.handlec                 C   s   t |ƒS rJ   ©ÚDrtNegatedExpression)rH   Ú
expressionr.   r.   r/   Úmake_NegatedExpressionl   s    z DrtParser.make_NegatedExpressionc                 C   sL   |   ¡ }|  d¡r*|  d¡tjkr*|  ¡  |  |¡}|  tj¡ t||d ƒS ©Nr   )	Úhandle_refsrN   rO   r   ÚCOMMAÚhandle_condsrS   ÚCLOSEr   )rH   rK   rU   ÚrefsÚcondsr.   r.   r/   rP   o   s    ÿÿ
zDrtParser.handle_DRSc                 C   sh   |   tj¡ g }|  d¡rX|  d¡tjkrX|rF|  d¡tjkrF|  ¡  | |  d¡¡ q|   tj¡ |S )Nr   Z
quantified)	rS   r   r)   rN   rO   r*   r]   ÚappendZget_next_token_variable)rH   r`   r.   r.   r/   r\   z   s    zDrtParser.handle_refsc                 C   sh   |   tj¡ g }|  d¡rX|  d¡tjkrX|rF|  d¡tjkrF|  ¡  | |  |¡¡ q|   tj¡ |S r[   )	rS   r   r)   rN   rO   r*   r]   rb   Úprocess_next_expression)rH   rU   ra   r.   r.   r/   r^   …   s    zDrtParser.handle_condsc                 C   s*   |   |¡}|  d¡ |  tj¡}t||ƒS )Nr#   )Úmake_VariableExpressionrS   rc   r   r+   ÚDrtProposition)rH   rK   rU   ÚvariableÚdrsr.   r.   r/   rT   �   s    

zDrtParser.handle_propc                 C   s
   t ||ƒS )zlThis method serves as a hook for other logic parsers that
        have different equality expression classes©ÚDrtEqualityExpression©rH   ÚfirstÚsecondr.   r.   r/   Úmake_EqualityExpression–   s    z!DrtParser.make_EqualityExpressionc                 C   s>   |t jkrdd„ S |t jv r tS |t jv r6dd„ }|S dS dS )zbThis method serves as a hook for other logic parsers that
        have different boolean operatorsc                 S   s   t | |d ƒS rJ   ©ÚDrtConcatenation©rk   rl   r.   r.   r/   Ú<lambda>Ÿ   r7   z9DrtParser.get_BooleanExpression_factory.<locals>.<lambda>c                 S   s@   t | tƒrt| j| j|ƒS t | tƒr4t| j| j|ƒS tdƒ‚d S ©Nz'Antecedent of implication must be a DRS)Ú
isinstancer   r`   ra   ro   rk   rl   Ú	Exceptionrp   r.   r.   r/   Úmake_imp_expression¤   s
    

zDDrtParser.get_BooleanExpression_factory.<locals>.make_imp_expressionN)r   r'   rD   ÚDrtOrExpressionrE   )rH   rK   ru   r.   r.   r/   Úget_BooleanExpression_factory›   s    


z'DrtParser.get_BooleanExpression_factoryc                 C   s
   |||ƒS rJ   r.   )rH   Úfactoryrk   rl   r.   r.   r/   Úmake_BooleanExpression¯   s    z DrtParser.make_BooleanExpressionc                 C   s
   t ||ƒS rJ   ©ÚDrtApplicationExpression)rH   ÚfunctionÚargumentr.   r.   r/   Úmake_ApplicationExpression²   s    z$DrtParser.make_ApplicationExpressionc                 C   s   t t|ƒƒS rJ   )ÚDrtVariableExpressionr   )rH   Únamer.   r.   r/   rd   µ   s    z!DrtParser.make_VariableExpressionc                 C   s
   t ||ƒS rJ   )ÚDrtLambdaExpression)rH   Ú	variablesÚtermr.   r.   r/   Úmake_LambdaExpression¸   s    zDrtParser.make_LambdaExpressionN)r$   r%   r&   Ú__doc__r@   rI   rL   rV   rZ   rP   r\   r^   rT   rm   rw   ry   r~   rd   r„   r.   r.   r.   r/   r0   :   s    r0   c                   @   s¼   e Zd ZdZeƒ Zedd„ ƒZdd„ Zdd„ Z	dd	„ Z
d
d„ Zdd„ Zd*dd„Zedd„ ƒZd+dd„Zdd„ Zd,dd„Zdd„ Zdd„ Zdd„ Zd d!„ Zd"d#„ Zd$d%„ Zd&d'„ Zd(d)„ ZdS )-ÚDrtExpressionz_
    This is the base abstract DRT Expression from which every DRT
    Expression extends.
    c                 C   s   | j  |¡S rJ   )Ú_drt_parserÚparse)ÚclsÚsr.   r.   r/   Ú
fromstringÄ   s    zDrtExpression.fromstringc                 C   s
   t | |ƒS rJ   rz   ©rH   Úotherr.   r.   r/   ÚapplytoÈ   s    zDrtExpression.applytoc                 C   s   t | ƒS rJ   rW   rG   r.   r.   r/   Ú__neg__Ë   s    zDrtExpression.__neg__c                 C   s   t S rJ   )ÚNotImplementedrŒ   r.   r.   r/   Ú__and__Î   s    zDrtExpression.__and__c                 C   s   t |tƒsJ ‚t| |ƒS rJ   )rs   r†   rv   rŒ   r.   r.   r/   Ú__or__Ñ   s    zDrtExpression.__or__c                 C   sN   t |tƒsJ ‚t | tƒr(t| j| j|ƒS t | tƒrBt| j| j|ƒS tdƒ‚d S rr   )	rs   r†   r   r`   ra   ro   rk   rl   rt   rŒ   r.   r.   r/   Ú__gt__Õ   s    

zDrtExpression.__gt__Nc                 C   s2   t |tƒsJ ‚|  ¡  ¡ }| ¡  ¡ }| ||¡S )a<  
        Check for logical equivalence.
        Pass the expression (self <-> other) to the theorem prover.
        If the prover says it is valid, then the self and other are equal.

        :param other: an ``DrtExpression`` to check equality against
        :param prover: a ``nltk.inference.api.Prover``
        )rs   r†   ÚsimplifyÚfolÚequiv)rH   r�   ZproverÚf1Úf2r.   r.   r/   r–   Ý   s    	zDrtExpression.equivc                 C   s   t d| jj ƒ‚d S )Nz#'%s' object has no attribute 'type')ÚAttributeErrorÚ	__class__r$   rG   r.   r.   r/   Útypeì   s    
ÿzDrtExpression.typec                 C   s
   t ƒ ‚d S rJ   ©ÚNotImplementedError)rH   Ú	signaturer.   r.   r/   Ú	typecheckò   s    zDrtExpression.typecheckc                 C   s   t | |d ƒS rJ   rn   rŒ   r.   r.   r/   Ú__add__õ   s    zDrtExpression.__add__Fc                 C   s
   t ƒ ‚dS )z¼
        Return the set of discourse referents in this DRS.
        :param recursive: bool Also find discourse referents in subterms?
        :return: list of ``Variable`` objects
        Nrœ   ©rH   Ú	recursiver.   r.   r/   Úget_refsø   s    zDrtExpression.get_refsc                 C   s2   t | tƒo0t | jtƒo0| jjjtjko0t | jt	ƒS )zIs self of the form "PRO(x)"?)
rs   r{   r|   ÚDrtAbstractVariableExpressionrf   r€   r   r(   r}   ÚDrtIndividualVariableExpressionrG   r.   r.   r/   Úis_pronoun_function   s    

ÿþ
üz!DrtExpression.is_pronoun_functionc                 C   s
   t ||ƒS rJ   rh   rj   r.   r.   r/   rm   	  s    z%DrtExpression.make_EqualityExpressionc                 C   s   t |ƒS rJ   )r   )rH   rf   r.   r.   r/   rd     s    z%DrtExpression.make_VariableExpressionc                 C   s   t | ƒS rJ   )Úresolve_anaphorarG   r.   r.   r/   r§     s    zDrtExpression.resolve_anaphorac                 C   s   |   dd„ | j¡S )Nc                 S   s   |   ¡ S rJ   )Úeliminate_equality)Úer.   r.   r/   rq     r7   z2DrtExpression.eliminate_equality.<locals>.<lambda>)Úvisit_structuredrš   rG   r.   r.   r/   r¨     s    z DrtExpression.eliminate_equalityc                 C   s   d  |  ¡ ¡S )zG
        Draw the DRS
        :return: the pretty print string
        Ú
)ÚjoinÚ_prettyrG   r.   r.   r/   Úpretty_format  s    zDrtExpression.pretty_formatc                 C   s   t |  ¡ ƒ d S rJ   )Úprintr®   rG   r.   r.   r/   Úpretty_print  s    zDrtExpression.pretty_printc                 C   s   t | ƒ ¡  d S rJ   )Ú	DrsDrawerÚdrawrG   r.   r.   r/   r²     s    zDrtExpression.draw)N)N)F)r$   r%   r&   r…   r0   r‡   Úclassmethodr‹   rŽ   r�   r‘   r’   r“   r–   Úpropertyr›   rŸ   r    r£   r¦   rm   rd   r§   r¨   r®   r°   r²   r.   r.   r.   r/   r†   ¼   s.   




	r†   c                   @   s„   e Zd ZdZddd„Zd dd„Zd	d
„ Zd!dd„Zdd„ Zdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ ZejZdd„ ZdS )"r   z%A Discourse Representation Structure.Nc                 C   s   || _ || _|| _dS )z²
        :param refs: list of ``DrtIndividualVariableExpression`` for the
            discourse referents
        :param conds: list of ``Expression`` for the conditions
        N)r`   ra   Ú
consequent)rH   r`   ra   rµ   r.   r.   r/   r@   &  s    zDRS.__init__FTc                    sd  ˆ| j v r‚ˆs| S | j  ˆ¡}| jr8| j ˆˆdˆ ¡}nd}t| j d|… ˆjg | j |d d…  ‡ ‡‡fdd„| jD ƒ|ƒS nÞˆ �rt| j ƒˆ ¡ @ D ]€‰t	ˆƒ}t
|ƒ‰| j  ˆ¡}| jrÔ| j ˆˆdˆ ¡}nd}t| j d|… |g | j |d d…  ‡ ‡‡fdd„| jD ƒ|ƒ} qš| j�r8| j ˆˆˆˆ ¡}nd}t| j ‡ ‡‡‡fdd„| jD ƒ|ƒS dS )ú_Replace all instances of variable v with expression E in self,
        where v is free in self.TNr2   c                    s   g | ]}|  ˆˆd ˆ ¡‘qS ©T©Úreplace©r4   Úcond)Úalpha_convertrY   rf   r.   r/   r6   A  s   ÿzDRS.replace.<locals>.<listcomp>c                    s   g | ]}|  ˆˆd ˆ ¡‘qS r·   r¸   rº   )r¼   ÚnewvarexÚrefr.   r/   r6   W  s   ÿc                    s   g | ]}|  ˆˆˆˆ ¡‘qS r.   r¸   rº   )r¼   rY   Úreplace_boundrf   r.   r/   r6   g  s   ÿ)r`   Úindexrµ   r¹   r   rf   ra   ÚsetÚfreer   r   )rH   rf   rY   r¿   r¼   Úirµ   Únewvarr.   )r¼   rY   r½   r¾   r¿   rf   r/   r¹   0  sZ    
ÿ&þú	ÿ$þú
ÿþúzDRS.replacec                 C   s@   t tjdd„ | jD ƒtƒ ƒ}| jr2| | j ¡ ¡ |t| jƒ S )z:see: Expression.free()c                 S   s   g | ]}|  ¡ ‘qS r.   )rÂ   ©r4   Úcr.   r.   r/   r6   p  r7   zDRS.free.<locals>.<listcomp>)	r   ÚoperatorÚor_ra   rÁ   rµ   ÚupdaterÂ   r`   )rH   Z
conds_freer.   r.   r/   rÂ   n  s    zDRS.freec                 C   sJ   |r@| j tt dd„ | jD ƒ¡ƒ }| jr<| | j d¡¡ |S | j S dS )ú#:see: AbstractExpression.get_refs()c                 s   s   | ]}|  d ¡V  qdS )TN)r£   rÅ   r.   r.   r/   Ú	<genexpr>y  r7   zDRS.get_refs.<locals>.<genexpr>TN)r`   Úlistr   Úfrom_iterablera   rµ   Úextendr£   )rH   r¢   Z
conds_refsr.   r.   r/   r£   u  s    ÿzDRS.get_refsc                 C   s.   t t|| jƒƒ}| jr&| || jƒ¡ ||ƒS ©ú:see: Expression.visit())rÌ   Úmapra   rµ   rb   )rH   r|   Ú
combinatorÚpartsr.   r.   r/   Úvisit�  s    z	DRS.visitc                 C   s.   | j r|| j ƒnd}|| jtt|| jƒƒ|ƒS )ú#:see: Expression.visit_structured()N)rµ   r`   rÌ   rÑ   ra   )rH   r|   rÒ   rµ   r.   r.   r/   rª   ˆ  s    zDRS.visit_structuredc                 C   s&  | }d}|t |jƒk r¼|j| }t|tƒr²t|jtƒr²t|jtƒr²ttt	|j
ƒ|jjh ƒ|jd |… |j|d d …  |jƒ}|jj|jjkrª| |jj|jdd¡}d}|d8 }|d7 }qg }|jD ]:}| ¡ }| ¡ }t|tƒrö|j
sö|jsö|jrÆ| |¡ qÆ|j�r|j ¡ nd }t|j
||ƒS )Nr   r2   F)Úlenra   rs   r   rk   r   rl   r   rÌ   rÁ   r`   rf   rµ   r¹   r¨   r”   rb   )rH   rg   rÃ   r»   ra   Znew_condZnew_cond_simprµ   r.   r.   r/   r¨   �  sF    
ÿ
þ
ýý

ÿþýüzDRS.eliminate_equalityc                 C   sÂ   | j rjd }| jr&ttdd„ | jD ƒƒ}|r<t|| j  ¡ ƒ}n
| j  ¡ }| jd d d… D ]}t||ƒ}qV|S | jsxtdƒ‚ttdd„ | jD ƒƒ}t	t
|  | j¡d d d… ƒD ]}t||ƒ}qª|S d S )Nc                 S   s   g | ]}|  ¡ ‘qS r.   ©r•   rÅ   r.   r.   r/   r6   µ  r7   zDRS.fol.<locals>.<listcomp>éÿÿÿÿz-Cannot convert DRS with no conditions to FOL.c                 S   s   g | ]}|  ¡ ‘qS r.   r×   rÅ   r.   r.   r/   r6   Ä  r7   )rµ   ra   r   r   r   r•   r`   r   rt   rÑ   r   Ú_order_ref_stringsr   )rH   Úaccumr¾   r.   r.   r/   r•   ±  s     
 zDRS.folc                    s¼   d  |  | j¡¡}dd„ dd„ | jD ƒD ƒ}tt|ƒgttt|ƒƒ ƒ‰ ddˆ   d d| ˆ ¡ d	 d
dˆ   d g‡ fdd„|D ƒ ddˆ   d g }| j	r¸t
 |tj| j	 ¡ ¡S |S )Nú c                 S   s   g | ]}|D ]}|‘qqS r.   r.   )r4   Z	cond_liner»   r.   r.   r/   r6   Ì  s   üzDRS._pretty.<locals>.<listcomp>c                 S   s   g | ]}t d d„ | ¡ ƒ‘qS )c                 S   s   |   ¡ S rJ   )Ústrip)rŠ   r.   r.   r/   rq   Ï  r7   z(DRS._pretty.<locals>.<listcomp>.<lambda>)Úfilterr­   rº   r.   r.   r/   r6   Î  s   z _Ú_z_ ú| ú |z|-ú-z-|c                    s   g | ]}d |  ˆ ¡ d ‘qS )rß   rà   )Úljust©r4   Úline©Úlengthr.   r/   r6   Ú  r7   z|_z_|)r¬   rÙ   r`   ra   ÚmaxrÖ   rÌ   rÑ   râ   rµ   ÚDrtBinaryExpressionÚ_assemble_prettyr   ÚIMPr­   )rH   Z	refs_lineZ
cond_linesrg   r.   rå   r/   r­   É  s*    ÿþýûúÿ	ÿzDRS._prettyc                 C   s¦   dd„ |D ƒ}g }g }g }g }|D ]J}t |ƒr:| |¡ q"t|ƒrN| |¡ q"t|ƒrb| |¡ q"| |¡ q"t|ƒt|dd„ d� t|dd„ d� t|dd„ d� S )Nc                 S   s   g | ]}d | ‘qS )ú%sr.   )r4   r¾   r.   r.   r/   r6   ä  r7   z*DRS._order_ref_strings.<locals>.<listcomp>c                 S   s(   t | dd … dgt| dd … ƒdk ƒS )Nr8   rØ   r   ©ÚintrÖ   ©Úvr.   r.   r/   rq   ô  r7   z(DRS._order_ref_strings.<locals>.<lambda>)Úkeyc                 S   s0   | d t | dd … dgt| dd … ƒdk ƒfS ©Nr   r2   rØ   rì   rî   r.   r.   r/   rq   õ  r7   c                 S   s0   | d t | dd … dgt| dd … ƒdk ƒfS rñ   rì   rî   r.   r.   r/   rq   ö  r7   )r   rb   r   r   Úsorted)rH   r`   ÚstringsZind_varsZ	func_varsZ
event_varsZ
other_varsrŠ   r.   r.   r/   rÙ   ã  s*    ÿþýÿzDRS._order_ref_stringsc                 C   s    t |tƒrœt| jƒt|jƒkrœ|}t| j|jƒD ] \}}|  |¡}| ||d¡}q0| j|jkrœt| jƒt|jƒkrœt| j|jƒD ]\}}||ks€ dS q€dS dS ©z}Defines equality modulo alphabetic variance.
        If we are comparing \x.M  and \y.N, then check equality of M and N[x/y].TF)	rs   r   rÖ   r`   Úziprd   r¹   rµ   ra   )rH   r�   Úconverted_otherÚr1Úr2ÚvarexZc1Úc2r.   r.   r/   Ú__eq__ù  s     

ÿþz
DRS.__eq__c                 C   s
   | |k S rJ   r.   rŒ   r.   r.   r/   Ú__ne__  s    z
DRS.__ne__c                 C   s^   d  d |  | j¡¡d dd„ | jD ƒ¡¡}| jrZtj| d tj d d| j  tj	 S |S )Nz([{}],[{}])ú,ú, c                 s   s   | ]}d | V  qdS ©rë   Nr.   rº   r.   r.   r/   rË     r7   zDRS.__str__.<locals>.<genexpr>rÛ   rë   )
Úformatr¬   rÙ   r`   ra   rµ   r   rM   rê   r_   ©rH   rg   r.   r.   r/   Ú__str__  s(    þÿþýüûúÿ	zDRS.__str__)N)FT)F)r$   r%   r&   r…   r@   r¹   rÂ   r£   rÔ   rª   r¨   r•   r­   rÙ   rû   rü   r   Ú__hash__r  r.   r.   r.   r/   r   #  s   


>
$r   c                 C   sB   t | jƒrt| ƒS t| jƒr$t| ƒS t| jƒr6t| ƒS t| ƒS dS )z—
    This is a factory method that instantiates and returns a subtype of
    ``DrtAbstractVariableExpression`` appropriate for the given variable.
    N)r   r€   r¥   r   ÚDrtFunctionVariableExpressionr   ÚDrtEventVariableExpressionÚDrtConstantExpression©rf   r.   r.   r/   r   "  s    


r   c                   @   s.   e Zd Zdd„ Zddd„Zdd„ Zdd	„ Zd
S )r¤   c                 C   s   | S rJ   r.   rG   r.   r.   r/   r•   2  s    z!DrtAbstractVariableExpression.folFc                 C   s   g S ©rÊ   r.   r¡   r.   r.   r/   r£   5  s    z&DrtAbstractVariableExpression.get_refsc                 C   s    d|  }dt |ƒ }||||gS ©Nrë   rÛ   ©rÖ   ©rH   rŠ   Úblankr.   r.   r/   r­   9  s    z%DrtAbstractVariableExpression._prettyc                 C   s   | S rJ   r.   rG   r.   r.   r/   r¨   >  s    z0DrtAbstractVariableExpression.eliminate_equalityN)F)r$   r%   r&   r•   r£   r­   r¨   r.   r.   r.   r/   r¤   1  s   
r¤   c                   @   s   e Zd ZdS )r¥   N©r$   r%   r&   r.   r.   r.   r/   r¥   B  s   r¥   c                   @   s   e Zd ZdS )r  Nr  r.   r.   r.   r/   r  H  s   r  c                   @   s   e Zd ZdS )r  Nr  r.   r.   r.   r/   r  N  s   r  c                   @   s   e Zd ZdS )r  Nr  r.   r.   r.   r/   r  T  s   r  c                   @   sn   e Zd Zdd„ Zddd„Zdd„ Zdd	d
„Zdd„ Zdd„ Ze	j
Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ ZdS )re   c                 C   s   || _ || _d S rJ   ©rf   rg   )rH   rf   rg   r.   r.   r/   r@   Y  s    zDrtProposition.__init__FTc                 C   sT   | j |kr6t|tƒsJ dƒ‚t|j | j ||||¡ƒS t| j | j ||||¡ƒS d S )Nz4Can only replace a proposition label with a variable)rf   rs   r¤   re   rg   r¹   )rH   rf   rY   r¿   r¼   r.   r.   r/   r¹   ]  s    
ÿþþþzDrtProposition.replacec                 C   s   t | j| j ¡ ƒS rJ   )re   rf   rg   r¨   rG   r.   r.   r/   r¨   l  s    z!DrtProposition.eliminate_equalityc                 C   s   |r| j  d¡S g S ©NT)rg   r£   r¡   r.   r.   r/   r£   o  s    zDrtProposition.get_refsc                 C   s$   | j |j ko"| j|jko"| j|jkS rJ   )rš   rf   rg   rŒ   r.   r.   r/   rû   r  s
    
ÿ
ýzDrtProposition.__eq__c                 C   s
   | |k S rJ   r.   rŒ   r.   r.   r/   rü   y  s    zDrtProposition.__ne__c                 C   s
   | j  ¡ S rJ   )rg   r•   rG   r.   r.   r/   r•   ~  s    zDrtProposition.folc                    sj   ˆj  ¡ }dtdˆj ƒ ‰ ‡ fdd„|d d… D ƒ‡fdd„|dd… D ƒ ‡ fdd„|dd … D ƒ S )	NrÛ   rë   c                    s   g | ]}ˆ d  | ‘qS ©rÛ   r.   rã   ©r  r.   r/   r6   …  r7   z*DrtProposition._pretty.<locals>.<listcomp>r2   c                    s   g | ]}d ˆ j  d | ‘qS )rë   r#   r  rã   rG   r.   r/   r6   †  r7   r8   c                    s   g | ]}ˆ d  | ‘qS r  r.   rã   r  r.   r/   r6   ‡  r7   )rg   r­   rÖ   rf   )rH   Zdrs_sr.   )r  rH   r/   r­   �  s    
ÿþÿzDrtProposition._prettyc                 C   s   ||| j ƒgƒS rÏ   )rg   ©rH   r|   rÒ   r.   r.   r/   rÔ   Š  s    zDrtProposition.visitc                 C   s   || j || jƒƒS )rÕ   r  r  r.   r.   r/   rª   Ž  s    zDrtProposition.visit_structuredc                 C   s   d| j › d| j› d�S )Nzprop(rþ   ú)r  rG   r.   r.   r/   r  ’  s    zDrtProposition.__str__N)FT)F)r$   r%   r&   r@   r¹   r¨   r£   rû   rü   r   r  r•   r­   rÔ   rª   r  r.   r.   r.   r/   re   X  s   

	re   c                   @   s&   e Zd Zdd„ Zd	dd„Zdd„ ZdS )
rX   c                 C   s   t | j ¡ ƒS rJ   )r   rƒ   r•   rG   r.   r.   r/   r•   —  s    zDrtNegatedExpression.folFc                 C   s   | j  |¡S r  )rƒ   r£   r¡   r.   r.   r/   r£   š  s    zDrtNegatedExpression.get_refsc                 C   sb   | j  ¡ }dd„ |d d… D ƒdd„ |dd… D ƒ dd„ |dd… D ƒ dd„ |dd … D ƒ S )	Nc                 S   s   g | ]}d | ‘qS ©z    r.   rã   r.   r.   r/   r6   ¡  r7   z0DrtNegatedExpression._pretty.<locals>.<listcomp>r8   c                 S   s   g | ]}d | ‘qS )z__  r.   rã   r.   r.   r/   r6   ¢  r7   r9   c                 S   s   g | ]}d | ‘qS )z  | r.   rã   r.   r.   r/   r6   £  r7   r:   c                 S   s   g | ]}d | ‘qS r  r.   rã   r.   r.   r/   r6   ¤  r7   )rƒ   r­   )rH   Ú
term_linesr.   r.   r/   r­   ž  s    
ÿþýÿzDrtNegatedExpression._prettyN)F©r$   r%   r&   r•   r£   r­   r.   r.   r.   r/   rX   –  s   
rX   c                   @   s.   e Zd Zdd„ Zdd„ Zdd„ Zddd	„Zd
S )r�   c                 C   s   |   || j | jt|ƒd¡¡S )zµRename all occurrences of the variable introduced by this variable
        binder in the expression to ``newvar``.
        :param newvar: ``Variable``, for the new variable
        T)rš   rƒ   r¹   rf   r   )rH   rÄ   r.   r.   r/   r¼   ©  s    þz!DrtLambdaExpression.alpha_convertc                 C   s   t | j| j ¡ ƒS rJ   )r   rf   rƒ   r•   rG   r.   r.   r/   r•   ³  s    zDrtLambdaExpression.folc                    sÄ   | j g}| j}|j| jkr.| |j ¡ |j}qd dd„ |D ƒ¡tj ‰| ¡ }dtˆƒ ‰ ‡ fdd„|d d… D ƒ‡ fdd„|dd… D ƒ ‡fd	d„|dd
… D ƒ ‡ fdd„|d
d … D ƒ S )NrÛ   c                 s   s   | ]}d | V  qdS rÿ   r.   )r4   rï   r.   r.   r/   rË   ¼  r7   z.DrtLambdaExpression._pretty.<locals>.<genexpr>c                    s   g | ]}d ˆ  | ‘qS r  r.   rã   r  r.   r/   r6   À  r7   z/DrtLambdaExpression._pretty.<locals>.<listcomp>r2   c                    s   g | ]}d ˆ  | ‘qS )z \  r.   rã   r  r.   r/   r6   Á  r7   r8   c                    s   g | ]}d ˆ  | ‘qS )z /\ r.   rã   )Ú
var_stringr.   r/   r6   Â  r7   r9   c                    s   g | ]}d ˆ  | ‘qS r  r.   rã   r  r.   r/   r6   Ã  r7   )	rf   rƒ   rš   rb   r¬   r   ÚDOTr­   rÖ   )rH   r‚   rƒ   r  r.   )r  r  r/   r­   ¶  s     ÿþýÿzDrtLambdaExpression._prettyFc                 C   s    |r| j g| j d¡ S | j gS ©rÊ   T)rf   rƒ   r£   r¡   r.   r.   r/   r£   Æ  s    ÿzDrtLambdaExpression.get_refsN)F)r$   r%   r&   r¼   r•   r­   r£   r.   r.   r.   r/   r�   ¨  s   
r�   c                   @   s2   e Zd Zddd„Zdd„ Zedd„ ƒZdd	„ Zd
S )rè   Fc                 C   s    |r| j  d¡| j d¡ S g S r  )rk   r£   rl   r¡   r.   r.   r/   r£   Î  s    ÿzDrtBinaryExpression.get_refsc                 C   s"   t  |  | j¡|  ¡ |  | j¡¡S rJ   )rè   ré   Ú_pretty_subexrk   ÚgetOprl   rG   r.   r.   r/   r­   Ô  s
    

ýzDrtBinaryExpression._prettyc                    sŽ   t t| ƒt|ƒƒ}t| |ƒ} t||ƒ}dtˆƒ ‰ tt| |ƒƒ}‡ fdd„|d d… D ƒ‡fdd„|dd… D ƒ ‡ fdd„|dd … D ƒ S )NrÛ   c                    s,   g | ]$\}}d | d  ˆ  d  | d  ‘qS r  r.   ©r4   Ú
first_lineZsecond_liner  r.   r/   r6   ã  s   ÿz8DrtBinaryExpression._assemble_pretty.<locals>.<listcomp>r8   c                    s,   g | ]$\}}d | d ˆ  d | d ‘qS )ú(rÛ   r  r.   r  )Úopr.   r/   r6   ç  s   ÿr9   c                    s,   g | ]$\}}d | d  ˆ  d  | d  ‘qS r  r.   r  r  r.   r/   r6   ë  s   ÿ)rç   rÖ   Ú_pad_verticallyrÌ   rõ   )Zfirst_linesr  Zsecond_linesÚ	max_linesZfirst_second_linesr.   )r  r  r/   ré   Û  s"    



þ

þü

þøÿz$DrtBinaryExpression._assemble_prettyc                 C   s   |  ¡ S rJ   ©r­   ©rH   Úsubexr.   r.   r/   r  ñ  s    z!DrtBinaryExpression._pretty_subexN)F)r$   r%   r&   r£   r­   Ústaticmethodré   r  r.   r.   r.   r/   rè   Í  s
   

rè   c                   @   s   e Zd ZdS )ÚDrtBooleanExpressionNr  r.   r.   r.   r/   r&  õ  s   r&  c                   @   s   e Zd Zdd„ Zdd„ ZdS )rv   c                 C   s   t | j ¡ | j ¡ ƒS rJ   )r   rk   r•   rl   rG   r.   r.   r/   r•   ú  s    zDrtOrExpression.folc                 C   s(   t |tƒrdd„ | ¡ D ƒS t | |¡S )Nc                 S   s   g | ]}|d d… ‘qS ©r2   rØ   r.   rã   r.   r.   r/   r6   ÿ  r7   z1DrtOrExpression._pretty_subex.<locals>.<listcomp>)rs   rv   r­   r&  r  r#  r.   r.   r/   r  ý  s    
zDrtOrExpression._pretty_subexN)r$   r%   r&   r•   r  r.   r.   r.   r/   rv   ù  s   rv   c                   @   s   e Zd Zdd„ ZdS )ri   c                 C   s   t | j ¡ | j ¡ ƒS rJ   )r   rk   r•   rl   rG   r.   r.   r/   r•     s    zDrtEqualityExpression.folN)r$   r%   r&   r•   r.   r.   r.   r/   ri     s   ri   c                   @   sŒ   e Zd ZdZd!dd„Zd"dd„Zd	d
„ Zdd„ Zd#dd„Zdd„ Z	dd„ Z
dd„ ZejZdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd „ ZdS )$ro   zDRS of the form '(DRS + DRS)'Nc                 C   s   t  | ||¡ || _d S rJ   )r&  r@   rµ   )rH   rk   rl   rµ   r.   r.   r/   r@     s    zDrtConcatenation.__init__FTc           
      C   sú   | j }| j}| j}||  ¡ v rX|rì| ||||¡}| ||||¡}|rì| ||||¡}n”|r¸t|  d¡ƒ| ¡ @ D ]D}tt|ƒƒ}	| ||	d|¡}| ||	d|¡}|rr| ||	d|¡}qr| ||||¡}| ||||¡}|rì| ||||¡}|  	|||¡S )r¶   T)
rk   rl   rµ   r£   r¹   rÁ   rÂ   r   r   rš   )
rH   rf   rY   r¿   r¼   rk   rl   rµ   r¾   rï   r.   r.   r/   r¹     s:    ÿÿÿÿzDrtConcatenation.replacec                 C   s   |   ¡ }t|tƒrJ ‚| ¡ S rJ   )r”   rs   ro   r¨   r  r.   r.   r/   r¨   6  s    z#DrtConcatenation.eliminate_equalityc                 C   s¦   | j  ¡ }| j ¡ }| jr$| j ¡ nd }t|tƒr”t|tƒr”t| d¡ƒt| d¡ƒ@ D ]}tt	|ƒƒ}| 
||d¡}qXt|j|j |j|j |ƒS |  |||¡S d S r  )rk   r”   rl   rµ   rs   r   rÁ   r£   r   r   r¹   r`   ra   rš   )rH   rk   rl   rµ   r¾   rÄ   r.   r.   r/   r”   <  s    

 zDrtConcatenation.simplifyc                 C   s8   | j  |¡| j |¡ }| jr4|r4| | j d¡¡ |S r  )rk   r£   rl   rµ   rÎ   )rH   r¢   r`   r.   r.   r/   r£   L  s    
zDrtConcatenation.get_refsc                 C   s   t jS rJ   )r   r'   rG   r.   r.   r/   r  S  s    zDrtConcatenation.getOpc                 C   s‚   t |tƒr~|  ¡ }| ¡ }t|ƒt|ƒkr~|}t||ƒD ] \}}|  |¡}| ||d¡}q8| j|jko|| j|jko|| j	|j	kS dS rô   )
rs   ro   r£   rÖ   rõ   rd   r¹   rk   rl   rµ   )rH   r�   Z	self_refsZ
other_refsrö   r÷   rø   rù   r.   r.   r/   rû   V  s    


ÿ
ýzDrtConcatenation.__eq__c                 C   s
   | |k S rJ   r.   rŒ   r.   r.   r/   rü   h  s    zDrtConcatenation.__ne__c                 C   s0   t | j ¡ | j ¡ ƒ}| jr,t|| j ¡ ƒ}|S rJ   )r   rk   r•   rl   rµ   r   )rH   r©   r.   r.   r/   r•   m  s    zDrtConcatenation.folc                 C   sB   t  |  | j¡|  ¡ |  | j¡¡}| jr>t  |tj| j 	¡ ¡}|S rJ   )
rè   ré   r  rk   r  rl   rµ   r   rê   r­   r  r.   r.   r/   r­   s  s    

ýÿzDrtConcatenation._prettyc                 C   s(   t |tƒrdd„ | ¡ D ƒS t | |¡S )Nc                 S   s   g | ]}|d d… ‘qS r'  r.   rã   r.   r.   r/   r6   �  r7   z2DrtConcatenation._pretty_subex.<locals>.<listcomp>)rs   ro   r­   r&  r  r#  r.   r.   r/   r    s    
zDrtConcatenation._pretty_subexc                 C   sB   | j r&||| jƒ|| jƒ|| j ƒgƒS ||| jƒ|| jƒgƒS dS )rÐ   N)rµ   rk   rl   r  r.   r.   r/   rÔ   „  s
    ÿzDrtConcatenation.visitc                 C   sn   |   | j¡}|   | j¡}tj| d |  ¡  d | tj }| jrjtj| d tj	 d d| j  tj S |S )NrÛ   rë   )
Ú
_str_subexrk   rl   r   rM   r  r_   rµ   r   rê   )rH   rk   rl   rg   r.   r.   r/   r  �  s&    $ÿþýüûúÿ	zDrtConcatenation.__str__c                 C   s,   d| }t |tƒr(|jd u r(|dd… S |S )Nrë   r2   rØ   )rs   ro   rµ   )rH   r$  rŠ   r.   r.   r/   r(  �  s    zDrtConcatenation._str_subex)N)FT)F)r$   r%   r&   r…   r@   r¹   r¨   r”   r£   r  rû   rü   r&  r  r•   r­   r  rÔ   r  r(  r.   r.   r.   r/   ro     s    

'
	ro   c                   @   s&   e Zd Zdd„ Zd	dd„Zdd„ ZdS )
r{   c                 C   s   t | j ¡ | j ¡ ƒS rJ   )r   r|   r•   r}   rG   r.   r.   r/   r•   ¥  s    zDrtApplicationExpression.folFc                 C   s    |r| j  d¡| j d¡ S g S r  )r|   r£   r}   r¡   r.   r.   r/   r£   ¨  s    ÿýz!DrtApplicationExpression.get_refsc                    sª   |   ¡ \}}| ¡ }dd„ |D ƒ}ttt|g| ƒƒ‰ t|ˆ ƒ}‡ fdd„|D ƒ}tt|tt|Ž ƒƒƒ}dd„ |d d… D ƒdd„ |dd… D ƒ dd„ |dd … D ƒ S )	Nc                 S   s   g | ]}|  ¡ ‘qS r.   r"  ©r4   Úargr.   r.   r/   r6   ³  r7   z4DrtApplicationExpression._pretty.<locals>.<listcomp>c                    s   g | ]}t |ˆ ƒ‘qS r.   )r   )r4   Z	arg_lines©r!  r.   r/   r6   ¶  r7   c                 S   s&   g | ]\}}|d  d   |¡ d  ‘qS r  ©r¬   ©r4   Z	func_lineZ	args_liner.   r.   r/   r6   ¹  s   ÿr8   c                 S   s&   g | ]\}}|d  d  |¡ d ‘qS )r  rý   r  r,  r-  r.   r.   r/   r6   ½  s   ÿr9   c                 S   s&   g | ]\}}|d  d   |¡ d  ‘qS r  r,  r-  r.   r.   r/   r6   Á  s   ÿ)Úuncurryr­   rç   rÑ   rÖ   r   rÌ   rõ   )rH   r|   ÚargsZfunction_linesZ
args_linesZfunc_args_linesr.   r+  r/   r­   °  s&    

þ
þü
þøÿz DrtApplicationExpression._prettyN)Fr  r.   r.   r.   r/   r{   ¤  s   
r{   c                 C   s&   dt | d ƒ g}| ||t | ƒ   S )NrÛ   r   r
  )Úlinesr!  Zpad_liner.   r.   r/   r   È  s    r   c                   @   s.   e Zd Zdd„ Zddd„Zdd„ Zd	d
„ ZdS )ÚPossibleAntecedentsc                 C   s   t | ƒS )zSet of free variables.)rÁ   rG   r.   r.   r/   rÂ   Î  s    zPossibleAntecedents.freeFTc                 C   s2   t ƒ }| D ]"}||kr"|  |¡ q
|  |¡ q
|S )r¶   )r1  rb   )rH   rf   rY   r¿   r¼   ÚresultÚitemr.   r.   r/   r¹   Ò  s    zPossibleAntecedents.replacec                 C   s   d|  }dt |ƒ }|||gS r	  r
  r  r.   r.   r/   r­   Ý  s    zPossibleAntecedents._prettyc                 C   s   dd  dd„ | D ƒ¡ d S )Nr!   rý   c                 s   s   | ]}d | V  qdS rÿ   r.   )r4   Úitr.   r.   r/   rË   ã  r7   z.PossibleAntecedents.__str__.<locals>.<genexpr>r"   r,  rG   r.   r.   r/   r  â  s    zPossibleAntecedents.__str__N)FT)r$   r%   r&   rÂ   r¹   r­   r  r.   r.   r.   r/   r1  Í  s   
r1  c                   @   s   e Zd ZdS )ÚAnaphoraResolutionExceptionNr  r.   r.   r.   r/   r5  æ  s   r5  c                 C   sZ  t | tƒr¸|  ¡ r„tƒ }|D ]>}| ¡ D ]0}|  |¡}|j| jjkr(|| jks(| |¡ q(qt	|ƒdkrr|d }n|}|  
| j|¡S t| j|| g ƒ}t| j|| g ƒ}|  ||¡S �nžt | tƒ�rpg }	| jD ]p}
t|
|| g ƒ}t |tƒ�r4t |jtƒ�r|j}|j|_||_t |jtƒ�r4|j�s4td|j ƒ‚|	 |¡ qÎ| j�r\t| j|| g ƒ}nd }|  | j|	|¡S t | tƒ�r€| S t | tƒ�r¤|  t| j|| g ƒ¡S t | tƒ�rú| j�rÌt| j|| g ƒ}nd }|  t| j|| g ƒt| j|| g ƒ|¡S t | tƒ�r.|  t| j|| g ƒt| j|| g ƒ¡S t | tƒ�rV|  | jt| j|| g ƒ¡S d S )Nr2   r   z+Variable '%s' does not resolve to anything.)rs   r   r¦   r1  r£   rd   rš   r}   rb   rÖ   rm   r§   r|   r   ra   r   rk   rl   r5  rµ   r`   r   r   rƒ   ro   r	   r   rf   )rY   ÚtrailZpossible_antecedentsZancestorr¾   ZrefexÚ
resolutionZ
r_functionZ
r_argumentZr_condsr»   Zr_condÚtemprµ   r.   r.   r/   r§   ê  s|    

ÿ

ÿÿÿýþÿr§   c                   @   sš   e Zd ZdZdZdZd%dd„Zdd	„ Zeefd
d„Zdd„ Z	dd„ Z
dd„ Zd&dd„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd „ Zd!d"„ Zd#d$„ ZdS )'r±   r9   é
   r<   TNc                 C   sÐ   d}|sºddl m}m} ddlm} |ƒ }| d¡ |ddd�}|rž||ddd	�}||_|| _|  || j	| j
¡\}	}
t|	| j	 d
ƒ}|
| j	 }||||d	�}n||ddd	�}| ¡  ||_|| _|| _|| _dS )a  
        :param drs: ``DrtExpression``, The DRS to be drawn
        :param size_canvas: bool, True if the canvas size should be the exact size of the DRS
        :param canvas: ``Canvas`` The canvas on which to draw the DRS.  If none is given, create a new canvas.
        Nr   )ÚCanvasÚTk)ÚFontZDRTZ	helveticaé   )ÚfamilyÚsize)ÚwidthÚheightéd   i,  )Útkinterr:  r;  Ztkinter.fontr<  ÚtitleÚfontÚcanvasÚ_visitÚ
OUTERSPACEÚTOPSPACErç   Úpackrg   Úmaster)rH   rg   Zsize_canvasrF  rK  r:  r;  r<  rE  ÚrightÚbottomr@  rA  r.   r.   r/   r@   B  s*    

zDrsDrawer.__init__c                 C   s   | j j d¡S )z Get the height of a line of textZ	linespace)rF  rE  ZmetricsrG   r.   r.   r/   Ú_get_text_heighth  s    zDrsDrawer._get_text_heightc                 C   s@   |   | j| j||¡ | jr,tƒ s,| j ¡  n|  | j||¡S dS )zDraw the DRSN)Ú_handlerg   Ú_draw_commandrK  r   ZmainlooprG  ©rH   r5   Úyr.   r.   r/   r²   l  s    zDrsDrawer.drawc                 C   s   |   || j||¡S )a!  
        Return the bottom-rightmost point without actually drawing the item

        :param expression: the item to visit
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        )rO  Ú_visit_command)rH   rY   r5   rR  r.   r.   r/   rG  u  s    	zDrsDrawer._visitc                 C   s€   t |tƒr&| jj||d| jj|d� nLt |tƒrr|\}}| j ||||¡ ||  ¡  | jd  }| j 	||||¡ |  
|||¡S )a   
        Draw the given item at the given location

        :param item: the item to draw
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        Únw)ÚanchorrE  Útextr8   )rs   ÚstrrF  Zcreate_textrE  ÚtupleZcreate_rectanglerN  ÚBUFFERZcreate_linerS  )rH   r3  r5   rR  rL  rM  Zhoriz_line_yr.   r.   r/   rP  €  s    	

ÿzDrsDrawer._draw_commandc                 C   s:   t |tƒr(|| jj |¡ ||  ¡  fS t |tƒr6|S dS )a  
        Return the bottom-rightmost point without actually drawing the item

        :param item: the item to visit
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        N)rs   rW  rF  rE  ZmeasurerN  rX  )rH   r3  r5   rR  r.   r.   r/   rS  –  s    	

zDrsDrawer._visit_commandr   c                 C   s  || j kr<z|j| }|j| }||fW S  ty:   Y n0 t|tƒrN| j}nŠt|tƒr`| j}nxt|t	ƒrr| j
}nft|tƒr„| j}nTt|tƒr–| j}nBt|tƒr¨| j}n0t|tƒrº| j}nt|tƒrÌ| j}nt|jjƒ‚|||||ƒ\}}|| |_|| |_||fS )a1  
        :param expression: the expression to handle
        :param command: the function to apply, either _draw_command or _visit_command
        :param x: the top of the current drawing area
        :param y: the left side of the current drawing area
        :return: the bottom-rightmost point
        )rS  Z_drawing_widthÚ_drawing_heightr™   rs   r¤   Ú_handle_VariableExpressionr   Ú_handle_DRSrX   Ú_handle_NegatedExpressionr�   Ú_handle_LambdaExpressionr	   Ú_handle_BinaryExpressionr{   Ú_handle_ApplicationExpressionr1  re   Ú_handle_DrtPropositionrt   rš   r$   )rH   rY   Úcommandr5   rR  rL  rM  rx   r.   r.   r/   rO  ¤  s8    













zDrsDrawer._handlec                 C   s   |d| ||ƒS )Nrë   r.   )rH   rY   rb  r5   rR  r.   r.   r/   r[  Ò  s    z$DrsDrawer._handle_VariableExpressionc              	   C   sR   |   tj||¡d }|  |j|||¡\}}|tj||  ||| |  ¡ ¡ƒ ||fS r[   )rS  r   ÚNOTrO  rƒ   Ú_get_centered_toprN  ©rH   rY   rb  r5   rR  rL  rM  r.   r.   r/   r]  Õ  s    ýz#DrsDrawer._handle_NegatedExpressionc                 C   s¼   || j  }|| j  }|jr2d dd„ |jD ƒ¡}nd}||||ƒ\}}|| j d 7 }|jr�|jD ],}	|  |	|||¡\}
}t||
ƒ}|| j 7 }q`n||  ¡ | j  7 }|| j 7 }|||f||ƒS )NrÛ   c                 s   s   | ]}d | V  qdS rÿ   r.   )r4   Úrr.   r.   r/   rË   ë  r7   z(DrsDrawer._handle_DRS.<locals>.<genexpr>z     r8   )rY  r`   r¬   ra   rO  rç   rN  )rH   rY   rb  r5   rR  ÚleftrM  r`   Z	max_rightr»   rL  r.   r.   r/   r\  å  s    




zDrsDrawer._handle_DRSc                    s  |  ¡ \}}t|tƒs$|j}|jg}ˆ  |ˆˆ¡d }t|g‡ ‡‡fdd„|D ƒ ƒ}|ˆ }	ˆ  ˆ|	|j¡}
ˆ  	||ˆ|
¡d }ˆ  ˆ|	ˆ  
¡ ¡}|tj||ƒd }t|ƒD ]R\}}ˆ  ˆ|	|j¡}ˆ  	||||¡d }|d t|ƒk r®|tjd ||ƒd }q®|tj||ƒd }||fS )Nr2   c                    s   g | ]}ˆ   |ˆˆ¡d  ‘qS r1   )rG  r)  rQ  r.   r/   r6     r7   z;DrsDrawer._handle_ApplicationExpression.<locals>.<listcomp>r   rÛ   )r.  rs   r¤   r|   r}   rG  rç   rd  rZ  rO  rN  r   rM   Ú	enumeraterÖ   r]   r_   )rH   rY   rb  r5   rR  r|   r/  Zfunction_bottomZ
max_bottomÚline_heightZfunction_drawing_toprL  Úcentred_string_toprÃ   r*  Zarg_drawing_topr.   rQ  r/   r`  þ  s4    
ÿÿ
ÿÿz'DrsDrawer._handle_ApplicationExpressionc              	   C   sd   t jd|j  t j }|  |||¡d }|  |j|||¡\}}||||  ||| |  ¡ ¡ƒ ||fS )Nrë   r   )	r   ZLAMBDArf   r  rS  rO  rƒ   rd  rN  )rH   rY   rb  r5   rR  r‚   rL  rM  r.   r.   r/   r^  )  s    ÿz"DrsDrawer._handle_LambdaExpressionc              
   C   sÞ   |   |jdd¡d }|   |jdd¡d }t||ƒ}|  |||  ¡ ¡}|tj||ƒd }	|jj}|  	|j||	|  |||¡¡\}	}
|d| 
¡  |	|ƒd }	|jj}|  	|j||	|  |||¡¡\}	}|tj|	|ƒd }	|	t|
|ƒfS )Nr   r2   z %s )rG  rk   rl   rç   rd  rN  r   rM   rZ  rO  r  r_   )rH   rY   rb  r5   rR  Zfirst_heightZsecond_heightri  rj  rL  Zfirst_bottomZsecond_bottomr.   r.   r/   r_  8  s0    

ÿüüz"DrsDrawer._handle_BinaryExpressionc                 C   s0   ||j ||ƒd }|  |j|||¡\}}||fS r[   )rf   rO  rƒ   re  r.   r.   r/   ra  ^  s    z DrsDrawer._handle_DrtPropositionc                 C   s   ||| d  S )zÅGet the y-coordinate of the point that a figure should start at if
        its height is 'item_height' and it needs to be centered in an area that
        starts at 'top' and is 'full_height' tall.r8   r.   )rH   ÚtopZfull_heightZitem_heightr.   r.   r/   rd  g  s    zDrsDrawer._get_centered_top)TN)r   r   )r$   r%   r&   rY  rI  rH  r@   rN  r²   rG  rP  rS  rO  r[  r]  r\  r`  r^  r_  ra  rd  r.   r.   r.   r/   r±   =  s$   
&	
.+&	r±   c                  C   sL  t dƒ tj} t | dƒƒ t | dƒƒ t | dƒƒ t | dƒƒ t | dƒƒ t | dƒƒ t | dƒƒ t | d	ƒƒ t | d
ƒƒ t dƒ t | dƒ ¡ ƒ t dƒ | dƒ}t |ƒ | tdƒ¡}t |ƒ t ||kƒ t dƒ t t| dƒƒƒ t t| dƒƒƒ t t| dƒƒƒ t dƒ | dƒ ¡  | dƒ ¡  | dƒ ¡  | dƒ ¡  | dƒ ¡  d S )Nz2====================TEST PARSE====================ú([x,y],[sees(x,y)])ú([x],[man(x), walks(x)])z\x.\y.([],[sees(x,y)])z\x.([],[walks(x)])(john)z$(([x],[walks(x)]) + ([y],[runs(y)]))z#(([],[walks(x)]) -> ([],[runs(x)]))z([x],[PRO(x), sees(John,x)])ú ([x],[man(x), -([],[walks(x)])])ú*([],[(([x],[man(x)]) -> ([],[walks(x)]))])z2====================Test fol()====================z\====================Test alpha conversion and lambda expression equality====================z\x.([],[P(x)])Úzz?====================Test resolve_anaphora()====================z,([x,y,z],[dog(x), cat(y), walks(z), PRO(z)])z3([],[(([x],[dog(x)]) -> ([y],[walks(y), PRO(y)]))])z(([x,y],[]) + ([],[PRO(x)]))z;====================Test pretty_print()====================ú([],[])z@([],[([x],[big(x), dog(x)]) -> ([],[bark(x)]) -([x],[walk(x)])])z'([x,y],[x=y]) + ([z],[dog(z), walk(z)])z4([],[([x],[]) | ([y],[]) | ([z],[dog(z), walk(z)])])z0\P.\Q.(([x],[]) + P(x) + Q(x))(\x.([],[dog(x)])))r¯   r†   r‹   r•   r¼   r   r§   r°   )ZdexprÚe1Úe2r.   r.   r/   Údemon  sB    
ÿÿrt  c               
   C   sf   zddl m}  W n, ty< } ztdƒ‚W Y d }~n
d }~0 0 g d¢}|D ]}t |¡}| ¡  qJd S )Nr   )r;  z,tkinter is required, but it's not available.)r5   rq  z([x],[])z([x],[man(x)])rl  rm  z\x.([],[man(x), walks(x)])z\x y.([],[sees(x,y)])z)([],[(([],[walks(x)]) + ([],[runs(x)]))])rn  ro  )rC  r;  ÚImportErrorÚ
ValueErrorr†   r‹   r²   )r;  r©   ZexpressionsÚdr.   r.   r/   Ú	test_draw–  s    
rx  Ú__main__)>rÇ   Ú	functoolsr   Ú	itertoolsr   Znltk.sem.logicr   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Z	nltk.utilr   r   r0   r†   r   r   r¤   r¥   r  r  r  re   rX   r�   rè   r&  rv   ri   ro   r{   r   rÌ   r1  rt   r5  r§   r±   rt  rx  r$   r.   r.   r.   r/   Ú<module>	   sX   l g  
ÿ
ÿ
ÿ>%(
 $S  3(
