B >?ð[7 ã@sÔdZddlmZmZddlZddlZddlmZddlm Z m Z ddl m Z ddl mZddlmZdd lmZd ZeƒZGd d „d eƒZd d„Zdd„Zdd„ZeGdd„deƒƒZdxdd„Ze eGdd„deƒƒƒZdydd„Zdzdd„ZeGdd„deƒƒZeGdd „d eƒƒZ Gd!d"„d"eƒZ!eGd#d$„d$e!ƒƒZ"eGd%d&„d&e!ƒƒZ#eGd'd(„d(e!ƒƒZ$eGd)d*„d*e!e ƒƒZ%e#ƒZ&e"ƒZ'e$ƒZ(e%ƒZ)d+d,„Z*Gd-d.„d.e+ƒZ,Gd/d0„d0e,ƒZ-Gd1d2„d2e,ƒZ.Gd3d4„d4e,ƒZ/d{d5d6„Z0Gd7d8„d8eƒZ1eGd9d:„d:e1ƒƒZ2eGd;d<„d„d>e2ƒƒƒZ4Gd?d@„d@e4ƒZ5GdAdB„dBe4ƒZ6GdCdD„dDe5ƒZ7GdEdF„dFe4ƒZ8dGdH„Z9GdIdJ„dJe2ƒZ:eGdKdL„dLe:ƒƒZ;eGdMdN„dNe:ƒƒZeGdSdT„dTe2ƒƒZ?eGdUdV„dVe2ƒƒZ@GdWdX„dXe@ƒZAGdYdZ„dZeAƒZBGd[d\„d\eAƒZCGd]d^„d^eAƒZDGd_d`„d`eAƒZEGdadb„dbe@ƒZFGdcdd„dde+ƒZGGdedf„dfeGƒZHGdgdh„dheGƒZIdidj„ZJdkdl„ZKdmdn„ZLdodp„ZMdqdr„ZNdsdt„ZOdudv„ZPeQdwkrÐeMƒdS)|zV A version of first order predicate logic, built on top of the typed lambda calculus. é)Úprint_functionÚunicode_literalsN)Ú defaultdict)ÚreduceÚtotal_ordering)Ú string_types)ÚTrie)ÚCounter)Úpython_2_unicode_compatibleÚAPPc@sèeZdZdZdgZdZdddgZdZddgZdZ dZ d Z d Z d Z d d d gZdZdddgZdZddgZdZdddgZdZdddgZdZddgZdZdgZeeeeZeeZe e e e gZeeeeeeeZdd„eDƒZdS)ÚTokensú\ÚexistsZsomeZexistÚallZforallÚ.ú(ú)ú,ú-Únotú!ú&Úandú^ú|Úorz->Zimpliesz=>z<->Ziffz<=>ú=z==z!=cCsg|]}t d|¡r|‘qS)z^[-\\.(),!&^|>=<]*$)ÚreÚmatch)Ú.0Úx©r!ú-lib/python3.7/site-packages/nltk/sem/logic.pyú GszTokens.N) Ú__name__Ú __module__Ú __qualname__ÚLAMBDAÚ LAMBDA_LISTÚEXISTSÚ EXISTS_LISTÚALLÚALL_LISTÚDOTÚOPENÚCLOSEÚCOMMAÚNOTÚNOT_LISTÚANDÚAND_LISTÚORÚOR_LISTÚIMPÚIMP_LISTÚIFFÚIFF_LISTÚEQÚEQ_LISTÚNEQÚNEQ_LISTZBINOPSÚQUANTSZPUNCTÚTOKENSÚSYMBOLSr!r!r!r"r s:      r cCsFdddddg}x2t|tjtjtjtjtjgƒD]}td|ƒq.WdS)z Boolean operators ZnegationZ conjunctionZ disjunctionZ implicationZ equivalencez%-15s %sN)Úzipr r1r3r5r7r9Úprint)ÚnamesÚpairr!r!r"Ú boolean_opsJs$rFcCs4ddg}x&t|tjtjgƒD]}td|ƒqWdS)z Equality predicates ZequalityZ inequalityz%-15s %sN)rBr r;r=rC)rDrEr!r!r"Úequality_predsSsrGcCs:dddg}x*t|tjtjtjgƒD]}td|ƒq"WdS)z Binding operators Z existentialZ universalÚlambdaz%-15s %sN)rBr r)r+r'rC)rDrEr!r!r"Ú binding_ops\s rIc@seZdZdZdFdd„ZdGdd„Zdd „Zd d „Zd d „Zdd„Z dHdd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Zd:d;„Zdd?„Z!d@dA„Z"dBdC„Z#dDdE„Z$dS)IÚ LogicParserz$A lambda calculus expression parser.FcCsÎt|tƒst‚d|_g|_||_g|_tdd„tj Dƒdd„tj Dƒt dfgdd„tj tj Dƒdd„tjDƒdd„tjDƒd d„tjDƒd d„tjDƒd d„tjDƒd gƒ|_t g|_d S)zd :param type_check: bool should type checking be performed? to their types. rcSsg|] }|df‘qS)ér!)rr r!r!r"r#€sz(LogicParser.__init__..cSsg|] }|df‘qS)ér!)rr r!r!r"r#sécSsg|] }|df‘qS)ér!)rr r!r!r"r#ƒscSsg|] }|df‘qS)ér!)rr r!r!r"r#„scSsg|] }|df‘qS)ér!)rr r!r!r"r#…scSsg|] }|df‘qS)ér!)rr r!r!r"r#†scSsg|] }|df‘qS)ér!)rr r!r!r"r#‡scSsg|] }|df‘qS)é r!)rr r!r!r"r#ˆs)Né N)Ú isinstanceÚboolÚAssertionErrorÚ _currentIndexÚ_bufferÚ type_checkÚ quote_charsÚdictr r(r2r r<r>r?r4r6r8r:Úoperator_precedenceÚright_associated_operations)ÚselfrZr!r!r"Ú__init__is  šzLogicParser.__init__Nc Csª| ¡}d|_| |¡\|_}y.| d¡}| d¡rJt|jd| d¡ƒ‚WnHtk r”}z*d||d||j df}td|ƒ‚Wdd}~XYnX|j r¦|  |¡|S)zà Parse the expression. :param data: str for the input to be parsed :param signature: ``dict`` that maps variable names to type strings :returns: a parsed Expression rNrKz %s %s %s^ú ) ÚrstriprXÚprocessrYÚprocess_next_expressionÚinRangeÚUnexpectedTokenExceptionÚtokenÚLogicalExpressionExceptionÚindexrZÚ typecheck)r_ÚdataÚ signatureÚmappingÚresultÚeÚmsgr!r!r"Úparses    zLogicParser.parsec Csœg}i}t| ¡ƒ}d}d}|}x,|t|ƒkrN|}| ||¡\} }| r\|sR|}|| 7}q$|} ||} d} xD| | kr°| | 7} | | } t|ƒ|t| ƒkr¬||t| ƒ} qnPqnWtj| krþ|rÚ||t|ƒ<| |¡d}||t|ƒ<| | ¡|t| ƒ7}q$||dkr.|rD||t|ƒ<| |¡d}n|s8|}|||7}|d7}q$W|rl||t|ƒ<| |¡t|ƒ|t|ƒ<t|ƒd|t|ƒd<||fS)zSplit the data into tokensÚrz rK)rÚget_all_symbolsÚlenÚprocess_quoted_tokenZLEAFÚappend) r_rkÚoutrmZ tokenTriergÚdata_idxZtoken_start_idxZ cur_data_idxZ quoted_tokenÚstÚcZsymbolr!r!r"rc¨s\             zLogicParser.processc Csd}||}|}xæ|jD]Ü\}}}} ||kr| r8||7}|d7}xŠ|||krÊ|||krš| rj|||7}|d7}t|ƒ|krŒtdd|ƒ‚|||7}n |||7}|d7}t|ƒ|krBtdd|ƒ‚qBW| rÜ|||7}|d7}|sòtddƒ‚PqW||fS)NrrrKz:End of input reached. Escape character [%s] found at end.z%End of input reached. Expected: [%s]zEmpty quoted token found)r[rtrh) r_rxrkrgrzÚiÚstartÚendÚescapeZ incl_quotesr!r!r"ruÞs>       z LogicParser.process_quoted_tokencCstjS)z#This method exists to be overridden)r rA)r_r!r!r"rsszLogicParser.get_all_symbolscCs|j|t|jƒkS)z6Return TRUE if the given location is within the buffer)rXrtrY)r_Úlocationr!r!r"reszLogicParser.inRangecCs`y8|dkr&|j|j}|jd7_n|j|j|}|Stk rZt|jdƒ‚YnXdS)zÃGet the next waiting token. If a location is given, then return the token at currentIndex+location without advancing currentIndex; setting it gives lookahead/lookback capability.NrK)rYrXÚ IndexErrorÚExpectedMoreTokensException)r_rÚtokr!r!r"rg s zLogicParser.tokencCs |tjkS)N)r r@)r_r‚r!r!r"Ú isvariableszLogicParser.isvariablecCs`y | ¡}Wn&tk r2t|jddd‚YnX| ||¡}|sTt|j|dd‚| ||¡S)zAParse the next complete expression from the stream and return it.rKzExpression expected.)Úmessage)rgrrXÚhandlerfÚattempt_adjuncts)r_Úcontextr‚Úaccumr!r!r"rds  z#LogicParser.process_next_expressioncCsr| |¡r| ||¡S|tjkr,| ||¡S|tjkrB| ||¡S|tjkrX| ||¡S|tj krn|  ||¡SdS)zgThis method is intended to be overridden for logics that use different operators or expressionsN) rƒÚhandle_variabler r2Úhandle_negationr(Ú handle_lambdar?Ú handle_quantr.Ú handle_open)r_r‚r‡r!r!r"r…-s         zLogicParser.handlecCsBd}x8||jkr<|j}| ||¡}| ||¡}| ||¡}qW|S)N)rXÚattempt_EqualityExpressionÚattempt_ApplicationExpressionÚattempt_BooleanExpression)r_Ú expressionr‡Zcur_idxr!r!r"r†?s   zLogicParser.attempt_adjunctscCs| | tj¡¡S)N)Úmake_NegatedExpressionrdr r1)r_r‚r‡r!r!r"rŠHszLogicParser.handle_negationcCst|ƒS)N)ÚNegatedExpression)r_r‘r!r!r"r’Ksz"LogicParser.make_NegatedExpressioncCs¬| |¡}| d¡r¨| d¡tjkr¨t|tƒsHt|tƒsHt|j d|ƒ‚| ¡|  ||  t ¡¡}x8| d¡rš| d¡tj krš| ¡|  ||  t ¡¡}qdW| tj¡|S)NrzW'%s' is an illegal predicate name. Individual variables may not be used as predicates.)Úmake_VariableExpressionrergr r.rUÚFunctionVariableExpressionÚConstantExpressionrhrXÚmake_ApplicationExpressionrdr r0ÚassertNextTokenr/)r_r‚r‡rˆr!r!r"r‰Ns"   zLogicParser.handle_variablec Cshy | ¡}Wn.tk r:}zt|jdƒ‚Wdd}~XYnXt| |¡tƒr`t|jd||fƒ‚t|ƒS)NzVariable expected.z;'%s' is an illegal variable name. Constants may not be %s.) rgrrirUr”r–rhrXÚVariable)r_Z descriptionr‚ror!r!r"Úget_next_token_variablels  z#LogicParser.get_next_token_variablecCsÐ| d¡st|jddd‚| d¡g}x\| d¡rN| d¡tjkr`| d¡s`t|jddd‚| | d¡¡srP| | d¡¡q*W| d¡r¨| d¡tjkr¨| ¡|  |¡}x|rÊ|  |  ¡|¡}q´W|S)NrrLz;Variable and Expression expected following lambda operator.)r„Z abstractedrKzExpression expected.) rerrXršrgr r-rƒrvrdÚmake_LambdaExpressionÚpop)r_r‚r‡Úvarsrˆr!r!r"r‹ys&    zLogicParser.handle_lambdacCsà| |¡}| d¡s*t|jdd|d‚| d¡g}x\| d¡r\| d¡tjkrn| d¡snt|jddd‚| | d¡¡s€P|  | d¡¡q8W| d¡r¶| d¡tjkr¶| ¡|  |¡}x|rÚ|  ||  ¡|¡}qÂW|S)NrrLz;Variable and Expression expected following quantifier '%s'.)r„Z quantifiedrKzExpression expected.) Ú get_QuantifiedExpression_factoryrerrXršrgr r-rƒrvrdÚmake_QuanifiedExpressionrœ)r_r‚r‡Úfactoryrrˆr!r!r"rŒ”s*      zLogicParser.handle_quantcCs.|tjkrtS|tjkrtS| |tj¡dS)z\This method serves as a hook for other logic parsers that have different quantifiersN)r r*ÚExistsExpressionr,Ú AllExpressionÚ assertTokenr?)r_r‚r!r!r"rž²s   z,LogicParser.get_QuantifiedExpression_factorycCs |||ƒS)Nr!)r_r ÚvariableÚtermr!r!r"rŸ¼sz$LogicParser.make_QuanifiedExpressioncCs| d¡}| tj¡|S)N)rdr˜r r/)r_r‚r‡rˆr!r!r"r¿s  zLogicParser.handle_opencCsb| d¡r^| d¡}|tjtjkr^| ||¡r^| ¡| || |¡¡}|tjkr^| |¡}|S)z»Attempt to make an equality expression. If the next token is an equality operator, then an EqualityExpression will be returned. Otherwise, the parameter will be returned.r) rergr r<r>Ú has_priorityÚmake_EqualityExpressionrdr’)r_r‘r‡r‚r!r!r"rŽÅs    z&LogicParser.attempt_EqualityExpressioncCs t||ƒS)zlThis method serves as a hook for other logic parsers that have different equality expression classes)ÚEqualityExpression)r_ÚfirstÚsecondr!r!r"r§Ösz#LogicParser.make_EqualityExpressioncCsXxR| d¡rR| d¡}| |¡}|rN| ||¡rN| ¡| ||| |¡¡}qPqW|S)z¶Attempt to make a boolean expression. If the next token is a boolean operator, then a BooleanExpression will be returned. Otherwise, the parameter will be returned.r)rergÚget_BooleanExpression_factoryr¦Úmake_BooleanExpressionrd)r_r‘r‡r‚r r!r!r"rÛs   z%LogicParser.attempt_BooleanExpressioncCs@|tjkrtS|tjkrtS|tjkr*tS|tjkr8tSdSdS)zbThis method serves as a hook for other logic parsers that have different boolean operatorsN) r r4Ú AndExpressionr6Ú OrExpressionr8Ú ImpExpressionr:Ú IffExpression)r_r‚r!r!r"r«ës    z)LogicParser.get_BooleanExpression_factorycCs |||ƒS)Nr!)r_r r©rªr!r!r"r¬ùsz"LogicParser.make_BooleanExpressioncCsÊ| t|¡rÆ| d¡rÆ| d¡tjkrÆt|tƒsbt|tƒsbt|t ƒsbt|t ƒsbt |j d|dƒ‚| ¡|  || t¡¡}x8| d¡r´| d¡tjkr´| ¡|  || t¡¡}q~W| tj¡|S|S)zíAttempt to make an application expression. The next tokens are a list of arguments in parens, then the argument expression is a function being applied to the arguments. Otherwise, return the argument expression.rzThe function '%szq' is not a Lambda Expression, an Application Expression, or a functional predicate, so it may not take arguments.)r¦r rergr r.rUÚLambdaExpressionÚApplicationExpressionr•r–rhrXr—rdr0r˜r/)r_r‘r‡rˆr!r!r"rüs(      z)LogicParser.attempt_ApplicationExpressioncCs t||ƒS)N)r²)r_ÚfunctionÚargumentr!r!r"r—sz&LogicParser.make_ApplicationExpressioncCs tt|ƒƒS)N)ÚVariableExpressionr™)r_Únamer!r!r"r”"sz#LogicParser.make_VariableExpressioncCs t||ƒS)N)r±)r_r¤r¥r!r!r"r›%sz!LogicParser.make_LambdaExpressioncCs2|j||j|kp0||jko0|j||j|kS)N)r]r^)r_Z operationr‡r!r!r"r¦(s  zLogicParser.has_priorityc Cs~y | ¡}Wn4tk r@}zt|jd|d‚Wdd}~XYnXt|tƒrd||krzt|j||ƒ‚n||krzt|j||ƒ‚dS)NzExpected token '%s'.)r„)rgrrirUÚlistrfrX)r_Úexpectedr‚ror!r!r"r˜0s " zLogicParser.assertNextTokencCs<t|tƒr"||kr8t|j||ƒ‚n||kr8t|j||ƒ‚dS)N)rUr·rfrX)r_r‚r¸r!r!r"r£?s  zLogicParser.assertTokencCs6| d¡rd| d¡}nd}d|jjd|dS)Nrz Next token: zNo more tokensú)rergÚ __class__r$)r_rpr!r!r"Ú__repr__Gs zLogicParser.__repr__)F)N)N)%r$r%r&Ú__doc__r`rqrcrursrergrƒrdr…r†rŠr’r‰ršr‹rŒržrŸrrŽr§rr«r¬rr—r”r›r¦r˜r£r¼r!r!r!r"rJesD $ 6$    #rJc Cs˜|dk r| |¡}|dkr tƒ}g}xnt| ¡ƒD]^\}}| ¡}| d¡s2|dkrVq2y| | |¡¡Wq2tk rŽt d||fƒ‚Yq2Xq2W|S)až Convert a file of First Order Formulas into a list of {Expression}s. :param s: the contents of the file :type s: str :param logic_parser: The parser to be used to parse the logical expression :type logic_parser: LogicParser :param encoding: the encoding of the input string, if it is binary :type encoding: str :return: a list of parsed formulas. :rtype: list(Expression) Nú#rrzUnable to parse line %s: %s) ÚdecoderJÚ enumerateÚ splitlinesÚstripÚ startswithrvrqrhÚ ValueError)ÚsZ logic_parserÚencodingZ statementsZlinenumÚliner!r!r"Ú read_logicOs  rÈc@sLeZdZdd„Zdd„Zdd„Zdd„Zd d „Zd d „Zd d„Z dd„Z dS)r™cCs t|tƒstd|ƒ‚||_dS)z7 :param name: the name of the variable z%s is not a stringN)rUrrWr¶)r_r¶r!r!r"r`pszVariable.__init__cCst|tƒo|j|jkS)N)rUr™r¶)r_Úotherr!r!r"Ú__eq__wszVariable.__eq__cCs ||k S)Nr!)r_rÉr!r!r"Ú__ne__zszVariable.__ne__cCst|tƒst‚|j|jkS)N)rUr™Ú TypeErrorr¶)r_rÉr!r!r"Ú__lt__}s zVariable.__lt__cCs | ||¡S)N)Úget)r_Úbindingsr!r!r"Úsubstitute_bindings‚szVariable.substitute_bindingscCs t|jƒS)N)Úhashr¶)r_r!r!r"Ú__hash__…szVariable.__hash__cCs|jS)N)r¶)r_r!r!r"Ú__str__ˆszVariable.__str__cCs d|jS)NzVariable('%s'))r¶)r_r!r!r"r¼‹szVariable.__repr__N) r$r%r&r`rÊrËrÍrÐrÒrÓr¼r!r!r!r"r™msr™cCsŒ|dk rFt|jƒrd}qJt|jƒr(d}qJt|jƒr8d}qJdsJtdƒ‚nd}td|t ¡fƒ}x(|dk r†||kr†td|t ¡fƒ}q`W|S)a Return a new, unique variable. :param pattern: ``Variable`` that is being replaced. The new variable must be the same type. :param term: a set of ``Variable`` objects that should not be returned from this function. :rtype: Variable NÚzÚFZe0Fz!Cannot generate a unique constantz%s%s)Ú is_indvarr¶Ú is_funcvarÚ is_eventvarrWr™Ú_counterrÎ)ÚpatternÚignoreÚprefixÚvr!r!r"Úunique_variables    rÞcCs:ttdt ¡ƒƒ}|r6xt|ƒD]}|t|ƒƒ}q"W|S)zX Return a skolem function over the variables in univ_scope param univ_scope zF%s)rµr™rÙrÎr·)Z univ_scopeZskolemrÝr!r!r"Úskolem_function«s rßc@s(eZdZdd„Zdd„Zedd„ƒZdS)ÚTypecCsd|S)Nz%sr!)r_r!r!r"r¼¹sz Type.__repr__cCs td|ƒS)Nz%s)rÑ)r_r!r!r"rÒ¼sz Type.__hash__cCst|ƒS)N)Ú read_type)ÚclsrÅr!r!r"Ú fromstring¿szType.fromstringN)r$r%r&r¼rÒÚ classmethodrãr!r!r!r"rà·sràc@sJeZdZdd„Zdd„Zdd„ZejZdd„Zd d „Z d d „Z d d„Z dS)Ú ComplexTypecCs<t|tƒstd|ƒ‚t|tƒs,td|ƒ‚||_||_dS)Nz%s is not a Type)rUràrWr©rª)r_r©rªr!r!r"r`ÆszComplexType.__init__cCs"t|tƒo |j|jko |j|jkS)N)rUrår©rª)r_rÉr!r!r"rÊÌs  zComplexType.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rËÓszComplexType.__ne__cCs2t|tƒr&|j |j¡o$|j |j¡S|tkSdS)N)rUrår©ÚmatchesrªÚANY_TYPE)r_rÉr!r!r"ræØs zComplexType.matchescCs^|tkr |St|tƒrJ|j |j¡}|j |j¡}|rD|rDt||ƒSdSn|tkrV|SdSdS)N)rçrUrår©Úresolverª)r_rÉÚfrÅr!r!r"rèÞs  zComplexType.resolvecCs$|tkrdtSd|j|jfSdS)Nz%sz<%s,%s>)rçr©rª)r_r!r!r"rÓíszComplexType.__str__cCs,|tkrt ¡Sd|j ¡|j ¡fSdS)Nz (%s -> %s))rçÚstrr©rª)r_r!r!r"rêószComplexType.strN) r$r%r&r`rÊrËràrÒrærèrÓrêr!r!r!r"råÄsråc@s2eZdZdd„Zdd„ZejZdd„Zdd„Zd S) Ú BasicTypecCst|tƒod|d|kS)Nz%s)rUrë)r_rÉr!r!r"rÊûszBasicType.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rËþszBasicType.__ne__cCs|tkp||kS)N)rç)r_rÉr!r!r"ræszBasicType.matchescCs| |¡r|SdSdS)N)ræ)r_rÉr!r!r"rès zBasicType.resolveN) r$r%r&rÊrËràrÒrærèr!r!r!r"rëús rëc@seZdZdd„Zdd„ZdS)Ú EntityTypecCsdS)Nror!)r_r!r!r"rÓszEntityType.__str__cCsdS)NZINDr!)r_r!r!r"rêszEntityType.strN)r$r%r&rÓrêr!r!r!r"rì srìc@seZdZdd„Zdd„ZdS)ÚTruthValueTypecCsdS)NÚtr!)r_r!r!r"rÓszTruthValueType.__str__cCsdS)NZBOOLr!)r_r!r!r"rêszTruthValueType.strN)r$r%r&rÓrêr!r!r!r"rísríc@seZdZdd„Zdd„ZdS)Ú EventTypecCsdS)NrÝr!)r_r!r!r"rÓ!szEventType.__str__cCsdS)NZEVENTr!)r_r!r!r"rê$sz EventType.strN)r$r%r&rÓrêr!r!r!r"rïsrïc@sbeZdZdd„Zedd„ƒZedd„ƒZdd„Zd d „Ze j Z d d „Z d d„Z dd„Z dd„ZdS)ÚAnyTypecCsdS)Nr!)r_r!r!r"r`*szAnyType.__init__cCs|S)Nr!)r_r!r!r"r©-sz AnyType.firstcCs|S)Nr!)r_r!r!r"rª1szAnyType.secondcCst|tƒp| |¡S)N)rUrðrÊ)r_rÉr!r!r"rÊ5szAnyType.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rË8szAnyType.__ne__cCsdS)NTr!)r_rÉr!r!r"ræ=szAnyType.matchescCs|S)Nr!)r_rÉr!r!r"rè@szAnyType.resolvecCsdS)Nú?r!)r_r!r!r"rÓCszAnyType.__str__cCsdS)NÚANYr!)r_r!r!r"rêFsz AnyType.strN)r$r%r&r`Úpropertyr©rªrÊrËràrÒrærèrÓrêr!r!r!r"rð(s  rðcCs t|tƒst‚| dd¡}|ddkr¸|ddks6t‚d}xVt|ƒD]J\}}|dkr^|d7}qD|dkr||d8}|dksŽt‚qD|dkrD|dkrDPqDWtt|d|…ƒt||dd…ƒƒS|dd tkrÌtS|dd tkràtS|dd t krôt St dd |dƒ‚dS) Nrarrrr¹éÿÿÿÿrºrKrz%szUnexpected character: '%s'.) rUrrWÚreplacerÀråráÚ ENTITY_TYPEÚ TRUTH_TYPErçrh)Z type_stringZ paren_countr{Úcharr!r!r"ráPs.   $rácseZdZ‡fdd„Z‡ZS)Ú TypeExceptioncstt|ƒ |¡dS)N)Úsuperrùr`)r_rp)r»r!r"r`nszTypeException.__init__)r$r%r&r`Ú __classcell__r!r!)r»r"rùmsrùcseZdZd‡fdd„ Z‡ZS)Ú"InconsistentTypeHierarchyExceptionNcs.|rd||f}nd|}tt|ƒ |¡dS)NzLThe variable '%s' was found in multiple places with different types in '%s'.zDThe variable '%s' was found in multiple places with different types.)rúrür`)r_r¤r‘rp)r»r!r"r`ss  z+InconsistentTypeHierarchyException.__init__)N)r$r%r&r`rûr!r!)r»r"rürsrücseZdZ‡fdd„Z‡ZS)ÚTypeResolutionExceptioncs tt|ƒ d||j|f¡dS)Nz9The type of '%s', '%s', cannot be resolved with type '%s')rúrýr`Útype)r_r‘Ú other_type)r»r!r"r`‚s z TypeResolutionException.__init__)r$r%r&r`rûr!r!)r»r"rýsrýcseZdZ‡fdd„Z‡ZS)ÚIllegalTypeExceptioncs$tt|ƒ d|jj|||f¡dS)Nz9Cannot set type of %s '%s' to '%s'; must match type '%s'.)rúrr`r»r$)r_r‘rÿZ allowed_type)r»r!r"r`Šs zIllegalTypeException.__init__)r$r%r&r`rûr!r!)r»r"r‰srcCs<x|D]}| |¡}qWx|dd…D]}| |¡q&W|S)zè Ensure correct typing across a collection of ``Expression`` objects. :param expressions: a collection of expressions :param signature: dict that maps variable names to types (or string representations of types) Nrô)rj)Z expressionsrlr‘r!r!r"rj‘s  rjc@s eZdZdZdd„Zdd„ZdS)ÚSubstituteBindingsIzT An interface for classes that can perform substitutions for variables. cCs tƒ‚dS)zÍ :return: The object that is obtained by replacing each variable bound by ``bindings`` with its values. Aliases are already resolved. (maybe?) :rtype: (any) N)ÚNotImplementedError)r_rÏr!r!r"rЧsz'SubstituteBindingsI.substitute_bindingscCs tƒ‚dS)zB :return: A list of all variables in this object. N)r)r_r!r!r"Ú variables°szSubstituteBindingsI.variablesN)r$r%r&r½rÐrr!r!r!r"r¡s rc@seZdZdZeƒZeddZed@dd„ƒZdd „Z d d „Z d d „Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„ZdAdd„Zdd„Zd d!„ZdBd"d#„Zd$d%„Zedfd&d'„ZdCd(d)„ZdDd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Z d6d7„Z!d8d9„Z"d:d;„Z#dd?„Z%dS)EÚ Expressionz other) to the theorem prover. If the prover says it is valid, then the self and other are equal. :param other: an ``Expression`` to check equality against :param prover: a ``nltk.inference.api.Prover`` z%s is not an ExpressionNr)ÚProver9)rUrrWZnltk.inferencerr°ÚsimplifyZprove)r_rÉZproverrZbicondr!r!r"Úequivñs  zExpression.equivcCs tt|ƒƒS)N)rÑÚrepr)r_r!r!r"rÒszExpression.__hash__cCsr|}xd| ¡D]X}||kr||}t|tƒr8| |¡}nt|tƒsPtd|fƒ‚| |¡}| ||¡}qW| ¡S)Nz@Can not substitute a non-expression value into an expression: %r) rrUr™r”rrÄrÐrõr)r_rÏÚexprÚvarÚvalr!r!r"rÐs     zExpression.substitute_bindingscszttƒ‰|rXxJ|D]B}||}tt|ƒƒ}t|tƒr<||_n t|ƒ|_ˆ| |¡qW|j ˆdt ‡fdd„ˆDƒƒS)zý Infer and check types. Raise exceptions if necessary. :param signature: dict that maps variable names to types (or string representations of types) :return: the signature, plus any additional type mappings )rlc3s |]}|ˆ|djfVqdS)rN)rþ)rÚkey)Úsigr!r"ú -sz'Expression.typecheck..) rr·rµr™rUràrþrárvÚ _set_typer\)r_rlrrÚvarExr!)rr"rjs     zExpression.typecheckcCs tƒ‚dS)zÉ Find the type of the given variable as it is used in this expression. For example, finding the type of "P" in "P(x) & Q(x,y)" yields "" :param variable: Variable N)r)r_r¤r!r!r"Úfindtype/szExpression.findtypecCs tƒ‚dS)zá Set the type of this expression to be the given type. Raise type exceptions where applicable. :param other_type: Type :param signature: dict(str -> list(AbstractVariableExpression)) N)r)r_rÿrlr!r!r"r8szExpression._set_typecsHtˆtƒstdˆƒ‚tˆtƒs,tdˆƒ‚| ‡‡‡‡fdd„|j¡S)au Replace every instance of 'variable' with 'expression' :param variable: ``Variable`` The variable to replace :param expression: ``Expression`` The expression with which to replace it :param replace_bound: bool Should bound variables be replaced? :param alpha_convert: bool Alpha convert automatically to avoid name clashes? z%s is not a Variablez%s is not an Expressioncs| ˆˆˆˆ¡S)N)rõ)ro)Ú alpha_convertr‘Ú replace_boundr¤r!r"ÚPsz$Expression.replace..)rUr™rWrÚvisit_structuredr»)r_r¤r‘rrr!)rr‘rr¤r"rõBs   zExpression.replacecs’‡fdd„‰|}x|ttˆ|ƒdd„dƒD]`\}}t|tƒrT| td|dƒ¡}n&t|tƒrv| td|dƒ¡}n|}| |j|d ¡}q*W|S) z&Rename auto-generated unique variablescs8t|tƒrt|gƒSt|tƒr$tƒS| ˆdd„¡SdS)NcSsttj|tƒƒS)N)rÚoperatorÚor_Úset)Úpartsr!r!r"r^sz>Expression.normalize..get_indiv_vars..)rUÚIndividualVariableExpressionr"ÚAbstractVariableExpressionÚvisit)ro)Úget_indiv_varsr!r"r'Ws    z,Expression.normalize..get_indiv_varscSs|jS)N)r¤)ror!r!r"rbsz&Expression.normalize..)rze0%srKzz%sT) rÀÚsortedrUÚEventVariableExpressionr»r™r$rõr¤)r_Znewvarsrnr{roZnewVarr!)r'r"Ú normalizeTs "  zExpression.normalizecCs tƒ‚dS)aR Recursively visit subexpressions. Apply 'function' to each subexpression and pass the result of each function application to the 'combinator' for aggregation: return combinator(map(function, self.subexpressions)) Bound variables are neither applied upon by the function nor given to the combinator. :param function: ``Function`` to call on each subexpression :param combinator: ``Function,R>`` to combine the results of the function calls :return: result of combination ``R`` N)r)r_r³Ú combinatorr!r!r"r&lszExpression.visitcs| |‡fdd„¡S)af Recursively visit subexpressions. Apply 'function' to each subexpression and pass the result of each function application to the 'combinator' for aggregation. The combinator must have the same signature as the constructor. The function is not applied to bound variables, but they are passed to the combinator. :param function: ``Function`` to call on each subexpression :param combinator: ``Function`` with the same signature as the constructor, to combine the results of the function calls :return: result of combination csˆ|ŽS)Nr!)r#)r+r!r"rŠsz-Expression.visit_structured..)r&)r_r³r+r!)r+r"r}s zExpression.visit_structuredcCsd|jj|fS)Nz<%s %s>)r»r$)r_r!r!r"r¼ŒszExpression.__repr__cCs| ¡S)N)rê)r_r!r!r"rÓszExpression.__str__cCs&| ¡tdd„| ¡| ¡BDƒƒBS)zþ Return a set of all the variables for binding substitution. The variables returned include all free (non-bound) individual variables and any variable starting with '?' or '@'. :return: set of ``Variable`` objects css |]}t d|j¡r|VqdS)z^[?@]N)rrr¶)rÚpr!r!r"ršsz'Expression.variables..)Úfreer"Ú predicatesÚ constants)r_r!r!r"r’szExpression.variablescCs| dd„dd„¡S)zÅ Return a set of all the free (non-bound) variables. This includes both individual and predicate variables, but not constants. :return: set of ``Variable`` objects cSs| ¡S)N)r-)ror!r!r"r¤sz!Expression.free..cSsttj|tƒƒS)N)rr r!r")r#r!r!r"r¤s)r&)r_r!r!r"r-szExpression.freecCs| dd„dd„¡S)zu Return a set of individual constants (non-predicates). :return: set of ``Variable`` objects cSs| ¡S)N)r/)ror!r!r"r­sz&Expression.constants..cSsttj|tƒƒS)N)rr r!r")r#r!r!r"r­s)r&)r_r!r!r"r/§szExpression.constantscCs| dd„dd„¡S)zu Return a set of predicates (constants, not variables). :return: set of ``Variable`` objects cSs| ¡S)N)r.)ror!r!r"r¶sz'Expression.predicates..cSsttj|tƒƒS)N)rr r!r")r#r!r!r"r¶s)r&)r_r!r!r"r.°szExpression.predicatescCs| dd„|j¡S)zD :return: beta-converted version of this expression cSs| ¡S)N)r)ror!r!r"r½sz%Expression.simplify..)rr»)r_r!r!r"r¹szExpression.simplifycCst|ƒS)N)rµ)r_r¤r!r!r"r”¿sz"Expression.make_VariableExpression)FN)N)N)FT)N)&r$r%r&r½rJrrrärãr rr r r r rrÍrÊrËrrÒrÐrjrrçrrõr*r&rr¼rÓrr-r/r.rr”r!r!r!r"r·sB           rc@s eZdZdZdd„Zdd„Zedd„ƒZedfd d „Z d d „Z d d„Z dd„Z dd„Z dd„Zdd„ZejZdd„Zdd„Zedd„ƒZedd„ƒZdd „ZdS)!r²a` This class is used to represent two related types of logical expressions. The first is a Predicate Expression, such as "P(x,y)". A predicate expression is comprised of a ``FunctionVariableExpression`` or ``ConstantExpression`` as the predicate and a list of Expressions as the arguments. The second is a an application of one expression to another, such as "(\x.dog(x))(fido)". The reason Predicate Expressions are treated as Application Expressions is that the Variable Expression predicate of the expression may be replaced with another Expression, such as a LambdaExpression, which would mean that the Predicate should be thought of as being applied to the arguments. The logical expression reader will always curry arguments in a application expression. So, "\x y.see(x,y)(john,mary)" will be represented internally as "((\x y.(see(x))(y))(john))(mary)". This simplifies the internals since there will always be exactly one argument in an application. The str() method will usually print the curried forms of application expressions. The one exception is when the the application expression is really a predicate expression (ie, underlying function is an ``AbstractVariableExpression``). This means that the example from above will be returned as "(\x y.see(x,y)(john))(mary)". cCs<t|tƒstd|ƒ‚t|tƒs,td|ƒ‚||_||_dS)zˆ :param function: ``Expression``, for the function expression :param argument: ``Expression``, for the argument z%s is not an ExpressionN)rUrrWr³r´)r_r³r´r!r!r"r`ászApplicationExpression.__init__cCsB|j ¡}|j ¡}t|tƒr2|j |j|¡ ¡S| ||¡SdS)N) r³rr´rUr±r¥rõr¤r»)r_r³r´r!r!r"rës    zApplicationExpression.simplifycCs t|jjtƒr|jjjStSdS)N)rUr³rþrårªrç)r_r!r!r"rþós zApplicationExpression.typeNc CsŠt|tƒst‚|dkrttƒ}|j t|¡y|j t |jj |ƒ|¡Wn<t k r„t d|j|jj |j|jj |jj j fƒ‚YnXdS)z:see Expression._set_type()NzqThe function '%s' is of type '%s' and cannot be applied to '%s' of type '%s'. Its argument must match type '%s'.)rUràrWrr·r´rrçr³rårþrýrùr©)r_rÿrlr!r!r"rúszApplicationExpression._set_typecs¶tˆtƒstdˆƒ‚| ¡r,| ¡\}}n|j}|jg}‡fdd„|g|Dƒ}g}x>|D]6}|tkr\|rˆx$|D]}| |¡rrPqrWq\|  |¡q\Wt |ƒdkr®t |ƒdStSdS)z:see Expression.findtype()z%s is not a Variablecsg|]}| ˆ¡‘qSr!)r)rÚarg)r¤r!r"r#sz2ApplicationExpression.findtype..rKrN) rUr™rWÚis_atomÚuncurryr³r´rçrærvrtr·)r_r¤r³ÚargsÚfoundÚuniqueréÚur!)r¤r"rs"     zApplicationExpression.findtypecCs,t|jtƒrtƒ}n |j ¡}||j ¡BS)z:see: Expression.constants())rUr³r%r"r/r´)r_Zfunction_constantsr!r!r"r/.s  zApplicationExpression.constantscCs4t|jtƒrt|jjgƒ}n |j ¡}||j ¡BS)z:see: Expression.predicates())rUr³r–r"r¤r.r´)r_Zfunction_predsr!r!r"r.6s  z ApplicationExpression.predicatescCs|||jƒ||jƒgƒS)z:see: Expression.visit())r³r´)r_r³r+r!r!r"r&>szApplicationExpression.visitcCs"t|tƒo |j|jko |j|jkS)N)rUr²r³r´)r_rÉr!r!r"rÊBs  zApplicationExpression.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rËIszApplicationExpression.__ne__cCs¸| ¡r*| ¡\}}d dd„|Dƒ¡}n|j}d|j}d|}d}t|tƒr‚t|jtƒrpt|jjt ƒs€d}qt|jt ƒsd}nt|tƒrd}|r¤t j |t j }|t j |t j S)Nrcss|]}d|VqdS)z%sNr!)rr0r!r!r"rRsz0ApplicationExpression.__str__..z%sFT)r1r2Újoinr³r´rUr±r¥r²r%ÚBooleanExpressionr r.r/)r_r³r3Zarg_strZ function_strZparenthesize_functionr!r!r"rÓNs$      zApplicationExpression.__str__cCs:|j}|jg}x"t|tƒr0| d|j¡|j}qW||fS)zh Uncurry this application expression return: A tuple (base-function, arg-list) r)r³r´rUr²Úinsert)r_r³r3r!r!r"r2hs   zApplicationExpression.uncurrycCs | ¡dS)z¯ Return uncurried base-function. If this is an atom, then the result will be a variable expression. Otherwise, it will be a lambda expression. r)r2)r_r!r!r"ÚpredvszApplicationExpression.predcCs | ¡dS)z+ Return uncurried arg-list rK)r2)r_r!r!r"r3szApplicationExpression.argscCs t|jtƒS)zk Is this expression an atom (as opposed to a lambda expression applied to a term)? )rUr:r%)r_r!r!r"r1†szApplicationExpression.is_atom)r$r%r&r½r`rrórþrçrrr/r.r&rÊrËrrÒrÓr2r:r3r1r!r!r!r"r²Ãs"   r²c@sneZdZdZdd„Zdd„Zddd „Zed fd d „Zd d„Z dd„Z dd„Z dd„Z dd„Z ejZdd„Zd S)r%zDThis class represents a variable to be used as a predicate or entitycCs t|tƒstd|ƒ‚||_dS)zA :param variable: ``Variable``, for the variable z%s is not a VariableN)rUr™rWr¤)r_r¤r!r!r"r`“sz#AbstractVariableExpression.__init__cCs|S)Nr!)r_r!r!r"ršsz#AbstractVariableExpression.simplifyFTcCsBt|tƒstd|ƒ‚t|tƒs,td|ƒ‚|j|kr:|S|SdS)z:see: Expression.replace()z%s is not an Variablez%s is not an ExpressionN)rUr™rWrr¤)r_r¤r‘rrr!r!r"rõs    z"AbstractVariableExpression.replaceNcCs‚t|tƒst‚|dkrttƒ}|}x,||jjD]}|j |¡}|s0t |ƒ‚q0W||jj  |¡x||jjD] }||_qpWdS)z:see Expression._set_type()N) rUràrWrr·r¤r¶rþrèrürv)r_rÿrlÚ resolutionrr!r!r"r¨s  z$AbstractVariableExpression._set_typecCs.t|tƒstd|ƒ‚|j|kr&|jStSdS)z:see Expression.findtype()z%s is not a VariableN)rUr™rWr¤rþrç)r_r¤r!r!r"r¹s z#AbstractVariableExpression.findtypecCstƒS)z:see: Expression.predicates())r")r_r!r!r"r.Ász%AbstractVariableExpression.predicatescCst|tƒo|j|jkS)zTAllow equality between instances of ``AbstractVariableExpression`` subtypes.)rUr%r¤)r_rÉr!r!r"rÊÅs z!AbstractVariableExpression.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rËÍsz!AbstractVariableExpression.__ne__cCst|tƒst‚|j|jkS)N)rUr%rÌr¤)r_rÉr!r!r"rÍÐs z!AbstractVariableExpression.__lt__cCs d|jS)Nz%s)r¤)r_r!r!r"rÓ×sz"AbstractVariableExpression.__str__)FT)r$r%r&r½r`rrõrçrrr.rÊrËrÍrrÒrÓr!r!r!r"r%Žs r%c@s@eZdZdZedfdd„Zdd„ZeeeƒZdd„Z d d „Z dS) r$zˆThis class represents variables that take the form of a single lowercase character (other than 'e') followed by zero or more digits.NcCsJt|tƒst‚|dkrttƒ}| t¡s4t||tƒ‚||jj   |¡dS)z:see Expression._set_type()N) rUràrWrr·rærörr¤r¶rv)r_rÿrlr!r!r"rßs   z&IndividualVariableExpression._set_typecCstS)N)rö)r_r!r!r"Ú _get_typeësz&IndividualVariableExpression._get_typecCs t|jgƒS)z:see: Expression.free())r"r¤)r_r!r!r"r-ðsz!IndividualVariableExpression.freecCstƒS)z:see: Expression.constants())r")r_r!r!r"r/ôsz&IndividualVariableExpression.constants) r$r%r&r½rçrr<rórþr-r/r!r!r!r"r$Ûs   r$c@s$eZdZdZeZdd„Zdd„ZdS)r•zwThis class represents variables that take the form of a single uppercase character followed by zero or more digits.cCs t|jgƒS)z:see: Expression.free())r"r¤)r_r!r!r"r-ÿszFunctionVariableExpression.freecCstƒS)z:see: Expression.constants())r")r_r!r!r"r/sz$FunctionVariableExpression.constantsN)r$r%r&r½rçrþr-r/r!r!r!r"r•ùsr•c@seZdZdZeZdS)r)z{This class represents variables that take the form of a single lowercase 'e' character followed by zero or more digits.N)r$r%r&r½Ú EVENT_TYPErþr!r!r!r"r)sr)c@s2eZdZdZeZedfdd„Zdd„Zdd„Z dS) r–ztThis class represents variables that do not take the form of a single character followed by zero or more digits.NcCs¦t|tƒst‚|dkrttƒ}|tkr,t}n|}|jtkrF| |j¡}x,||j j D]}|j |¡}|sTt |ƒ‚qTW||j j   |¡x||j j D] }||_q”WdS)z:see Expression._set_type()N) rUràrWrr·rçrörþrèr¤r¶rürv)r_rÿrlr;rr!r!r"rs    zConstantExpression._set_typecCstƒS)z:see: Expression.free())r")r_r!r!r"r--szConstantExpression.freecCs t|jgƒS)z:see: Expression.constants())r"r¤)r_r!r!r"r/1szConstantExpression.constants) r$r%r&r½rörþrçrr-r/r!r!r!r"r–s r–cCsXt|tƒstd|ƒ‚t|jƒr(t|ƒSt|jƒr:t|ƒSt|jƒrLt |ƒSt |ƒSdS)z” This is a factory method that instantiates and returns a subtype of ``AbstractVariableExpression`` appropriate for the given variable. z%s is not a VariableN) rUr™rWrÖr¶r$r×r•rØr)r–)r¤r!r!r"rµ6s   rµc@s`eZdZdZdd„Zddd„Zdd „Zd d „Zd d „Zdd„Z dd„Z dd„Z dd„Z e jZdS)ÚVariableBinderExpressionz‘This an abstract class for any Expression that binds a variable in an Expression. This includes LambdaExpressions and Quantified ExpressionscCs<t|tƒstd|ƒ‚t|tƒs,td|ƒ‚||_||_dS)zs :param variable: ``Variable``, for the variable :param term: ``Expression``, for the term z%s is not a Variablez%s is not an ExpressionN)rUr™rWrr¤r¥)r_r¤r¥r!r!r"r`Jsz!VariableBinderExpression.__init__FTc Cs¶t|tƒstd|ƒ‚t|tƒs,td|ƒ‚|j|krr|rlt|tƒsPtd|ƒ‚| |j|j ||d|¡¡S|Sn@|r–|j|  ¡kr–|  t |jd¡}| |j|j ||||¡¡SdS)z:see: Expression.replace()z%s is not a Variablez%s is not an Expressionz&%s is not a AbstractVariableExpressionT)rÚN) rUr™rWrr¤r%r»r¥rõr-rrÞ)r_r¤r‘rrr!r!r"rõTs      z VariableBinderExpression.replacecCs4t|tƒstd|ƒ‚| ||j |jt|ƒ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 z%s is not a VariableT)rUr™rWr»r¥rõr¤rµ)r_Znewvarr!r!r"rrsz&VariableBinderExpression.alpha_convertcCs|j ¡t|jgƒS)z:see: Expression.free())r¥r-r"r¤)r_r!r!r"r-|szVariableBinderExpression.freecCs4t|tƒstd|ƒ‚||jkr$tS|j |¡SdS)z:see Expression.findtype()z%s is not a VariableN)rUr™rWr¤rçr¥r)r_r¤r!r!r"r€s z!VariableBinderExpression.findtypecCs|||jƒgƒS)z:see: Expression.visit())r¥)r_r³r+r!r!r"r&ˆszVariableBinderExpression.visitcCs||j||jƒƒS)z#:see: Expression.visit_structured())r¤r¥)r_r³r+r!r!r"rŒsz)VariableBinderExpression.visit_structuredcCsZt||jƒst||jƒrR|j|jkr0|j|jkSt|jƒ}|j|j |j|¡kSndSdS)z~Defines equality modulo alphabetic variance. If we are comparing \x.M and \y.N, then check equality of M and N[x/y].FN)rUr»r¤r¥rµrõ)r_rÉZvarexr!r!r"rÊs    zVariableBinderExpression.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rËszVariableBinderExpression.__ne__N)FT)r$r%r&r½r`rõrr-rr&rrÊrËrrÒr!r!r!r"r>Fs   r>c@s.eZdZedd„ƒZedfdd„Zdd„ZdS)r±cCst|j |j¡|jjƒS)N)rår¥rr¤rþ)r_r!r!r"rþ¥szLambdaExpression.typeNcCsHt|tƒst‚|dkrttƒ}|j |j|¡|j  |¡sDt ||ƒ‚dS)z:see Expression._set_type()N) rUràrWrr·r¥rrªrþrèrý)r_rÿrlr!r!r"r©s  zLambdaExpression._set_typecCsZ|jg}|j}x"|j|jkr0| |j¡|j}qWtjd dd„|Dƒ¡tjd|S)Nracss|]}d|VqdS)z%sNr!)rrÝr!r!r"r¼sz+LambdaExpression.__str__..z%s)r¤r¥r»rvr r'r7r-)r_rr¥r!r!r"rÓ´s   zLambdaExpression.__str__)r$r%r&rórþrçrrÓr!r!r!r"r±£s  r±c@s.eZdZedd„ƒZedfdd„Zdd„ZdS)ÚQuantifiedExpressioncCstS)N)r÷)r_r!r!r"rþÄszQuantifiedExpression.typeNcCsFt|tƒst‚|dkrttƒ}| t¡s4t||tƒ‚|j  t|¡dS)z:see Expression._set_type()N) rUràrWrr·rær÷rr¥r)r_rÿrlr!r!r"rÈs   zQuantifiedExpression._set_typecCs`|jg}|j}x"|j|jkr0| |j¡|j}qW| ¡dd dd„|Dƒ¡tjd|S)Nracss|]}d|VqdS)z%sNr!)rrÝr!r!r"rÜsz/QuantifiedExpression.__str__..z%s)r¤r¥r»rvÚ getQuantifierr7r r-)r_rr¥r!r!r"rÓÓs   zQuantifiedExpression.__str__)r$r%r&rórþrçrrÓr!r!r!r"r?Âs  r?c@seZdZdd„ZdS)r¡cCstjS)N)r r))r_r!r!r"r@ãszExistsExpression.getQuantifierN)r$r%r&r@r!r!r!r"r¡âsr¡c@seZdZdd„ZdS)r¢cCstjS)N)r r+)r_r!r!r"r@èszAllExpression.getQuantifierN)r$r%r&r@r!r!r!r"r¢çsr¢c@sdeZdZdd„Zedd„ƒZedfdd„Zdd „Zd d „Z d d „Z dd„Z dd„Z e jZdd„ZdS)r“cCs t|tƒstd|ƒ‚||_dS)Nz%s is not an Expression)rUrrWr¥)r_r¥r!r!r"r`îszNegatedExpression.__init__cCstS)N)r÷)r_r!r!r"rþòszNegatedExpression.typeNcCsFt|tƒst‚|dkrttƒ}| t¡s4t||tƒ‚|j  t|¡dS)z:see Expression._set_type()N) rUràrWrr·rær÷rr¥r)r_rÿrlr!r!r"rös   zNegatedExpression._set_typecCs"t|tƒstd|ƒ‚|j |¡S)Nz%s is not a Variable)rUr™rWr¥r)r_r¤r!r!r"rszNegatedExpression.findtypecCs|||jƒgƒS)z:see: Expression.visit())r¥)r_r³r+r!r!r"r&szNegatedExpression.visitcCs|jS)z:see: Expression.negate())r¥)r_r!r!r"r  szNegatedExpression.negatecCst|tƒo|j|jkS)N)rUr“r¥)r_rÉr!r!r"rÊ szNegatedExpression.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rËszNegatedExpression.__ne__cCstjd|jS)Nz%s)r r1r¥)r_r!r!r"rÓszNegatedExpression.__str__)r$r%r&r`rórþrçrrr&r rÊrËrrÒrÓr!r!r!r"r“ìs  r“c@sVeZdZdd„Zedd„ƒZdd„Zdd„Zd d „Zd d „Z e j Z d d„Z dd„Z dS)ÚBinaryExpressioncCs<t|tƒstd|ƒ‚t|tƒs,td|ƒ‚||_||_dS)Nz%s is not an Expression)rUrrWr©rª)r_r©rªr!r!r"r`szBinaryExpression.__init__cCstS)N)r÷)r_r!r!r"rþ!szBinaryExpression.typecCsVt|tƒstd|ƒ‚|j |¡}|j |¡}||ks>|tkrB|S|tkrN|StSdS)z:see Expression.findtype()z%s is not a VariableN)rUr™rWr©rrªrç)r_r¤rérÅr!r!r"r%s  zBinaryExpression.findtypecCs|||jƒ||jƒgƒS)z:see: Expression.visit())r©rª)r_r³r+r!r!r"r&1szBinaryExpression.visitcCs0t||jƒst||jƒo.|j|jko.|j|jkS)N)rUr»r©rª)r_rÉr!r!r"rÊ5s zBinaryExpression.__eq__cCs ||k S)Nr!)r_rÉr!r!r"rË<szBinaryExpression.__ne__cCs<| |j¡}| |j¡}tj|d| ¡d|tjS)Nra)Ú _str_subexr©rªr r.ÚgetOpr/)r_r©rªr!r!r"rÓAs  zBinaryExpression.__str__cCsd|S)Nz%sr!)r_Úsubexr!r!r"rBFszBinaryExpression._str_subexN)r$r%r&r`rórþrr&rÊrËrrÒrÓrBr!r!r!r"rAs  rAc@seZdZedfdd„ZdS)r8NcCsTt|tƒst‚|dkrttƒ}| t¡s4t||tƒ‚|j  t|¡|j   t|¡dS)z:see Expression._set_type()N) rUràrWrr·rær÷rr©rrª)r_rÿrlr!r!r"rKs  zBooleanExpression._set_type)r$r%r&rçrr!r!r!r"r8Jsr8c@s eZdZdZdd„Zdd„ZdS)r­z"This class represents conjunctionscCstjS)N)r r3)r_r!r!r"rC[szAndExpression.getOpcCs"d|}t|tƒr|dd…S|S)Nz%srKrô)rUr­)r_rDrÅr!r!r"rB^s  zAndExpression._str_subexN)r$r%r&r½rCrBr!r!r!r"r­Xsr­c@s eZdZdZdd„Zdd„ZdS)r®z"This class represents disjunctionscCstjS)N)r r5)r_r!r!r"rChszOrExpression.getOpcCs"d|}t|tƒr|dd…S|S)Nz%srKrô)rUr®)r_rDrÅr!r!r"rBks  zOrExpression._str_subexN)r$r%r&r½rCrBr!r!r!r"r®esr®c@seZdZdZdd„ZdS)r¯z"This class represents implicationscCstjS)N)r r7)r_r!r!r"rCuszImpExpression.getOpN)r$r%r&r½rCr!r!r!r"r¯rsr¯c@seZdZdZdd„ZdS)r°z$This class represents biconditionalscCstjS)N)r r9)r_r!r!r"rC|szIffExpression.getOpN)r$r%r&r½rCr!r!r!r"r°ysr°c@s&eZdZdZedfdd„Zdd„ZdS)r¨z:This class represents equality expressions like "(x = y)".NcCsTt|tƒst‚|dkrttƒ}| t¡s4t||tƒ‚|j  t |¡|j   t |¡dS)z:see Expression._set_type()N) rUràrWrr·rær÷rr©rrörª)r_rÿrlr!r!r"rƒs  zEqualityExpression._set_typecCstjS)N)r r;)r_r!r!r"rCszEqualityExpression.getOp)r$r%r&r½rçrrCr!r!r!r"r¨€s r¨c@seZdZdd„ZdS)rhcCs||_t ||¡dS)N)riÚ Exceptionr`)r_rir„r!r!r"r`—sz#LogicalExpressionException.__init__N)r$r%r&r`r!r!r!r"rh–srhc@seZdZddd„ZdS)rfNcCsN|r|rd||f}n&|r4d|}|r<|d|7}nd|}t |||¡dS)Nz-Unexpected token: '%s'. Expected token '%s'.zUnexpected token: '%s'.z zExpected token '%s'.)rhr`)r_riZ unexpectedr¸r„rpr!r!r"r`s z!UnexpectedTokenException.__init__)NNN)r$r%r&r`r!r!r!r"rfœsrfc@seZdZddd„ZdS)rNcCs|sd}t ||d|¡dS)NzMore tokens expected.zEnd of input found. )rhr`)r_rir„r!r!r"r`­sz$ExpectedMoreTokensException.__init__)N)r$r%r&r`r!r!r!r"r¬srcCs&t|tƒstd|ƒ‚t d|¡dk S)zÆ An individual variable must be a single lowercase character other than 'e', followed by zero or more digits. :param expr: str :return: bool True if expr is of the correct form z%s is not a stringz ^[a-df-z]\d*$N)rUrrWrr)rr!r!r"rÖµsrÖcCs&t|tƒstd|ƒ‚t d|¡dk S)z³ A function variable must be a single uppercase character followed by zero or more digits. :param expr: str :return: bool True if expr is of the correct form z%s is not a stringz ^[A-Z]\d*$N)rUrrWrr)rr!r!r"r×Ásr×cCs&t|tƒstd|ƒ‚t d|¡dk S)zµ An event variable must be a single lowercase 'e' character followed by zero or more digits. :param expr: str :return: bool True if expr is of the correct form z%s is not a stringz^e\d*$N)rUrrWrr)rr!r!r"rØÍsrØcCsHtj}tdƒt|dƒƒt|dƒƒt|dƒƒt|dƒƒt|dƒƒt|dƒƒt|dƒƒt|d ƒƒt|d ƒƒt|d ƒƒt|d ƒƒt|d ƒƒt|dƒƒt|dƒƒt|dƒƒtdƒt|dƒ ¡ƒt|dƒ ¡ƒt|dƒ ¡ƒt|dƒ ¡ƒtdƒ|dƒ}t|ƒ| tdƒ¡}t|ƒt||kƒdS)Nz3====================Test reader====================Zjohnzman(x)z-man(x)z(man(x) & tall(x) & walks(x))z&exists x.(man(x) & tall(x) & walks(x))z \x.man(x)z\x.man(x)(john)z\x y.sees(x,y)z\x y.sees(x,y)(a,b)z(\x.exists y.walks(x,y))(x)zexists x.x = yzexists x.(x = y)zP(x) & x=y & P(y)z\P Q.exists x.(P(x) & Q(x))zman(x) <-> tall(x)z5====================Test simplify====================z\x.\y.sees(x,y)(john)(mary)z\x.\y.sees(x,y)(john, mary)z,all x.(man(x) & (\x.exists y.walks(x,y))(x))z5(\P.\Q.exists x.(P(x) & Q(x)))(\x.dog(x))(\x.bark(x))z\====================Test alpha conversion and binder expression equality====================z exists x.P(x)rÔ)rrãrCrrr™)ZlexprZe1Ze2r!r!r"ÚdemoÙs8               rFcCsttdƒtdƒtdƒtdƒtdƒtdƒtdƒtdƒtd ƒtd ƒtd ƒtd ƒtd ƒtdƒdS)Nz:====================Test reader errors====================z (P(x) & Q(x)z((P(x) &) & Q(x))zP(x) -> zP(xzP(x,zP(x,)rz exists x.r z\ x y.zP(x)Q(x)z (P(x)Q(x)z exists x -> y)rCÚ demoExceptionr!r!r!r"Ú demo_errorsúsrHc CsJyt |¡Wn6tk rD}ztd|jj|fƒWdd}~XYnXdS)Nz%s: %s)rrãrhrCr»r$)rÅror!r!r"rG srGcCstd| ¡|jfƒdS)Nz%s : %s)rCrêrþ)Úexr!r!r"Ú printtypesrJÚ__main__)NN)NN)N)N)Rr½Z __future__rrrr Ú collectionsrÚ functoolsrrZsixrZ nltk.utilrZnltk.internalsr Z nltk.compatr r rÙÚobjectr rFrGrIrJrÈr™rÞrßràrårërìrírïrðr÷rör=rçrárErùrürýrrjrrr²r%r$r•r)r–rµr>r±r?r¡r¢r“rAr8r­r®r¯r°r¨rhrfrrÖr×rØrFrHrGrJr$r!r!r!r"Ú s¼     +   l     5     !   K  K']   , 0      !