jdZddlZddlZddlmZddlmZmZddlm Z ddl m Z dZ e Z Gdd Zd Zd Zd ZGd dZdidZeGddZdidZdjdZGddZGddeZGddeZGddeZGddeZGddeZGd d!eeZeZeZeZ eZ!d"Z"Gd#d$e#Z$Gd%d&e$Z%Gd'd(e$Z&Gd)d*e$Z'djd+Z(Gd,d-Z)Gd.d/e)Z*d0Z+d1Z,Gd2d3e*Z-eGd4d5e*Z.Gd6d7e.Z/Gd8d9e.Z0Gd:d;e/Z1Gd<d=e.Z2d>Z3Gd?d@e*Z4GdAdBe4Z5GdCdDe4Z6GdEdFe6Z7GdGdHe6Z8GdIdJe6Z9GdKdLe*Z:GdMdNe*Z;GdOdPe;Z<GdQdRe<Z=GdSdTe<Z>GdUdVe<Z?GdWdXe<Z@GdYdZe;ZAGd[d\e#ZBGd]d^eBZCGd_d`eBZDdaZEdbZFdcZGddZHdeZIdfZJdgZKeLdhkr eHdSdS)kzV A version of first order predicate logic, built on top of the typed lambda calculus. N) defaultdict)reducetotal_ordering)Counter)TrieAPPceZdZdZdgZdZgdZdZddgZdZ dgZ dZ dZ d Z d Zd Zgd Zd ZgdZdZddgZdZgdZdZgdZdZddgZdZdgZeezezezZeeze zZe e e egZeezezezezezezZ de DZ!dS)Tokens\exists)somer existallforalliota.(),-)notr!&)andr^|or->)impliesrz=><->)iffr z<=>=z==z!=c<g|]}tjd||S)z^[-\\.(),!&^|>=<]*$)rematch.0xs q/home/lighthouse/badge-speaker-benchmark/.benchmark-venv-community/lib/python3.11/site-packages/nltk/sem/logic.py zTokens.Es*HHHQBH-CQ$G$GHqHHHN)"__name__ __module__ __qualname__LAMBDA LAMBDA_LISTEXISTS EXISTS_LISTALLALL_LISTIOTA IOTA_LISTDOTOPENCLOSECOMMANOTNOT_LISTANDAND_LISTOROR_LISTIMPIMP_LISTIFFIFF_LISTEQEQ_LISTNEQNEQ_LISTBINOPSQUANTSPUNCTTOKENSSYMBOLSr+r)r r s3 F&KF---K Cx H DI C D E E C   H C   H BSkG C&&&H C$$$H BDkG CvH ( *X 5F 8 #i /F $u %E g  (6 1K ?% G( RFIH&HHHGGGr+r cgd}t|tjtjtjtjtjgD]}td|zdS)z Boolean operators )negation conjunction disjunction implication equivalence%-15s %sN)zipr r;r=r?rArCprintnamespairs r) boolean_opsr[Hs^ U T TEEFJ FIvz6:VWW"" kD !!!!""r+cddg}t|tjtjgD]}t d|zdS)z Equality predicates equality inequalityrUN)rVr rErGrWrXs r)equality_predsr_QsP &EEFIvz233"" kD !!!!""r+cgd}t|tjtjtjtjgD]}t d|zdS)z Binding operators ) existential universallambdarUN)rVr r1r3r/r5rWrXs r) binding_opsrdZsY 3 2 2EEFM6:v}fkRSS"" kD !!!!""r+ceZdZdZdZd&dZd'dZdZdZd Z d Z d'd Z d Z d Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%dS)( LogicParserz$A lambda calculus expression parser.Fc`t|tsJd|_g|_d|_||_ g|_tdtj Ddtj Dztdfgzdtj tj zDzdtjDzdtjDzdtjDzd tjDzd tjDzd gz|_tg|_d S) z :param type_check: should type checking be performed to their types? :type type_check: bool rcg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..s 0 0 0aV 0 0 0r+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..///!1v///r+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..s@@@!1v@@@r+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..s---!1v---r+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..rmr+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..s...!1v...r+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..rmr+cg|]}|dfS) rNr&s r)r*z(LogicParser.__init__..rmr+)N N) isinstancebool _currentIndex_buffer _parse_depth type_check quote_charsdictr r0r<rrFrHrJr>r@rBrDoperator_precedenceright_associated_operations)selfrs r)__init__zLogicParser.__init__msV *d+++++ $ /#' 0 0V/ 0 0 0//v/// 0Qxj A@v~?@@@ A.-v}---  . 0/v///  0 /.v~...  /0/v/// 00/v/// 0l  $ $  -05(((r+Nc |}d|_d|_||\|_} |d}|dr+t|jdz|dnK#t$r>}d ||d||j dz z}td||d}~wwxYw|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 rNrjz {} {} {}^ )rstripr~rprocessrprocess_next_expressioninRangeUnexpectedTokenExceptiontokenLogicalExpressionExceptionformatindexr typecheck)rdata signaturemappingresultemsgs r)parsezLogicParser.parses {{}} $ T 2 2 g ?11$77F||A V.t/AA/EtzzRS}}UUU V) ? ? ?&&q$gagk6J0JKKC,T377Q > ? ? (   Y ' ' ' sAB C!9CCcg}i}t|}d}d}|}|t|krV|}|||\} }| r |s|}|| z };|} ||} d} | | vrN| | z } | | } t||z t| kr||t| z} nn| | vNtj| vre|r)||t|<||d}||t|<|| |t| z }nJ||dvr,|r)||t|<||d}n|s|}|||z }|dz }|t|kV|r'||t|<||t||t|<t|dz|t|dz<||fS)zSplit the data into tokensrz rj)rget_all_symbolslenprocess_quoted_tokenLEAFappend) rroutr tokenTrierdata_idxtoken_start_idx cur_data_idx quoted_tokenstcsymbols r)rzLogicParser.processsG--//00 "T""#L%)%>%>x%N%N "L( 3&2O%BXAFr''! Ut99x'#f++55XF 34AA r''yB(7GCHH%JJu%%%E$,C! 6"""CKK'>W,,#,;C) 5))) " 3*2T(^+EA MT""N   /GCHH  JJu   IIC #D A C1 G|r+cd}||}|}|jD]\}}}} ||kr| r||z }|dz }|||kr|||krD| r |||z }|dz }t||krtdd|z|||z }n |||z }|dz }t||krtdd|z|||k| r |||z }|dz }|stddn||fS)Nrrjz:End of input reached. Escape character [%s] found at end.z%End of input reached. Expected: [%s]zEmpty quoted token found)rrr) rrrrristartendescape incl_quotess r)rz LogicParser.process_quoted_tokensu N /3/?   +E3 EzzQJEQ1gnnAw&((&-!T!W,EQt99>>"< $!FHN!O## a(a(FA4yyA~~8 "Ls"R!1gnn&%T!W$EQW4T;UVVV9:axr+ctjS)z#This method exists to be overridden)r rMrs r)rzLogicParser.get_all_symbols s ~r+cB|j|zt|jkS)z6Return TRUE if the given location is within the buffer)r~rr)rlocations r)rzLogicParser.inRange s!H,s4 A%A  A%c|tjvSN)r rLrrs r) isvariablezLogicParser.isvariables&-''r+c|xjdz c_ |j|jkr t|jdzd|jz |}n,#t $r}t |jdzd|d}~wwxYw|||}|st|j|d||||xjdzc_S#|xjdzc_wxYw)zAParse the next complete expression from the stream and return it.rjz2Expression nesting exceeds the maximum depth (%d).Expression expected.messageN) rMAX_PARSE_DEPTHrr~rrhandlerattempt_adjuncts)rcontextrraccums r)rz#LogicParser.process_next_expression"s? Q # 4#7771&*H*+  jjll.   1&*4J  KKW--E .&5K((88    "   D   "      s00CAC B"A<<BACC+c||r|||S|tjvr|||S|tjvr|||S|tjvr|||S|tj kr| ||SdS)zgThis method is intended to be overridden for logics that use different operators or expressionsN) rhandle_variabler r<handle_negationr0 handle_lambdarJ handle_quantr8 handle_openrrrs r)rzLogicParser.handleBs ??3   2''W55 5 FO # #''W55 5 F& & &%%c733 3 FM ! !$$S'22 2 FK  ##C11 1 r+cd}||jkrT|j}|||}|||}|||}||jkT|Sr)r~attempt_EqualityExpressionattempt_ApplicationExpressionattempt_BooleanExpression)r expressionrcur_idxs r)rzLogicParser.attempt_adjunctsTst+++(G88WMMJ;;JPPJ77 GLLJ +++ r+cf||tjSr)make_NegatedExpressionrr r;rs r)rzLogicParser.handle_negation]s&**4+G+G +S+STTTr+c t|SrNegatedExpression)rrs r)rz"LogicParser.make_NegatedExpression`s ,,,r+cN||}|dry|dtjkrUt |t s-t |tst|j d|z|| || t}|dr|dtj krz|| || t}|dr#|dtj kz|tj|S)NrzW'%s' is an illegal predicate name. Individual variables may not be used as predicates.)make_VariableExpressionrrr r8r|FunctionVariableExpressionConstantExpressionrr~make_ApplicationExpressionrrr:assertNextTokenr9rrrrs r)rzLogicParser.handle_variablecsq,,S11 <<?? /tzz!}} ;;e%?@@ )JJ 1&"$'( JJLLL33t33C88E,,q// djjmmv|&C&C 77477<<,,q// djjmmv|&C&C   . . . r+c$ |}n(#t$r}t|jd|d}~wwxYwt||t rt |jd|d|dt|S)NzVariable expected.'z5' is an illegal variable name. Constants may not be r) rrrr|rrrr~Variable)r descriptionrrs r)get_next_token_variablez#LogicParser.get_next_token_variables T**,,CC* T T T-ag7KLLRS S T d223779K L L ,"".1cc;;;@  }}s <7<c|dst|jdzd|dg} |dr8|dt jkr.|dst|jdzd||dsn)||d|dr7|dt jkr|| |}|r*| | |}|*|S) Nrrlz;Variable and Expression expected following lambda operator.r abstractedTrjr) rrr~rrr r7rrrmake_LambdaExpressionpop)rrrvarsrs r)rzLogicParser.handle_lambdas}||A -"Q&U ,,\::; D<<??  1 ++DLLOO+1&*4J??4::a==11  KK44\BB C C C D <<?? tzz!}} :: JJLLL,,S11 B..txxzz5AAE B r+cL||}|dst|jdzd|z|dg} |dr8|dt jkr.|dst|jdzd||dsn)| |d|dr7|dt jkr|| |}|r+| || |}|+|S) Nrrlz;Variable and Expression expected following quantifier '%s'.r quantifiedTrjr) get_QuantifiedExpression_factoryrrr~rrr r7rrrmake_QuanifiedExpressionr)rrrfactoryrrs r)rzLogicParser.handle_quants77<<||A -"Q&U  ,,\::; D<<??  1 ++DLLOO+1&*4J??4::a==11  KK44\BB C C C D <<?? tzz!}} :: JJLLL,,S11 N11'488::uMME N r+c|tjvrtS|tjvrtS|tjvrt S||tjdS)z\This method serves as a hook for other logic parsers that have different quantifiersN) r r2ExistsExpressionr4 AllExpressionr6IotaExpression assertTokenrJrs r)rz,LogicParser.get_QuantifiedExpression_factorys] &$ $ $# # FO # # F$ $ $! !   S&- 0 0 0 0 0r+c|||SrrN)rrvariableterms r)rz$LogicParser.make_QuanifiedExpressionswx&&&r+cn|d}|tj|Sr)rrr r9rs r)rzLogicParser.handle_opens0,,T22 V\*** r+c||dr|d}|tjtjzvrv|||r`|||||}|tjvr||}|S)zAttempt 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) rrr rFrH has_prioritymake_EqualityExpressionrr)rrrrs r)rz&LogicParser.attempt_EqualityExpressions <<?? I**Q--Cfnv6664;L;LW<<6 !99 < AndExpressionr@ OrExpressionrB ImpExpressionrD IffExpressionrs r)rz)LogicParser.get_BooleanExpression_factorysU &/ ! ! FN " "  FO # # FO # # 4r+c|||SrrN)rrrrs r)rz"LogicParser.make_BooleanExpressionswuf%%%r+c|t|r|dr|dtjkrt |tsZt |tsEt |ts0t |tst|j d|zdz|| ||t}|dr|dtjkrz|| ||t}|dr#|dtjkz|tj|S|S)zAttempt 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.)rrrrr r8r|LambdaExpressionApplicationExpressionrrrr~rrr:rr9)rrrrs r)rz)LogicParser.attempt_ApplicationExpression!s   S' * * ||A 4::a==FK#?#?":/?@@ &z3HII 'z3MNN 'z3EFF  5*+j8.. 77 < )rr __class__r,)rrs r)__repr__zLogicParser.__repr__lsN <<?? # 4::a==0CC"CT^,,t3c9C??r+)Fr)&r,r-r.__doc__rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr"rNr+r)rfrfcs9..O$1$1$1$1L8444l"""HAAA M M M M(((###@222$UUU---<   6< 1 1 1''' "111 <   &&&!!!F999222000    R R RRRR@@@@@r+rfc|||}|t}g}t|D]\}}|}|ds|dkr5 |||_#t$r}td|d||d}~wwxYw|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#rzUnable to parse line r) decoderf enumerate splitlinesstrip startswithrrr ValueError)s logic_parserencoding statementslinenumliners r) read_logicr2ts HHX  "}} J"1<<>>22OO zz|| ??3   42::  O   l0066 7 7 7 7) O O OFWFFFFGGQ N O s(B** C4C  Cc8eZdZdZdZdZdZdZdZdZ dS) rcXt|ts Jd|z||_dS)z7 :param name: the name of the variable %s is not a stringN)r|strrrs r)rzVariable.__init__s3$$$AA&:T&AAAA r+cLt|to|j|jkSr)r|rrrothers r)__eq__zVariable.__eq__s %**FtyEJ/FFr+cZt|tst|j|jkSr)r|r TypeErrorrr8s r)__lt__zVariable.__lt__s(%** Oy5:%%r+c.|||Sr)getrbindingss r)substitute_bindingszVariable.substitute_bindingss||D$'''r+c*t|jSr)hashrrs r)__hash__zVariable.__hash__sDIr+c|jSrrrs r)__str__zVariable.__str__s yr+cd|jzS)NzVariable('%s')rGrs r)r"zVariable.__repr__s$)++r+N) r,r-r.rr:r=rBrErHr"rNr+r)rrsGGG&&& (((,,,,,r+rcl|Ot|jrd}n:t|jrd}n#t|jrd}n Jdd}t |t }|4||vr0t |t }|||v0|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 NzFe0Fz!Cannot generate a unique constant) is_indvarr is_funcvar is_eventvarr_counterr?)patternignoreprefixvs r)unique_variablerVs W\ " " >FF  % % >FF  & & >FF == = = =F,HLLNN,,--A  f 0 00 1 1  f Hr+cttdtz}|r*t |D]}|t|}|S)zX Return a skolem function over the variables in univ_scope param univ_scope zF%s)rrrQr?r) univ_scopeskolemrUs r)skolem_functionrZsd  )? @ @ A AF3j!! 3 3AV.q1122FF Mr+c0eZdZdZdZedZdS)Typec d|zSN%srNrs r)r"z Type.__repr__s d{r+c&td|zSr^)rDrs r)rEz Type.__hash__sD4K   r+c t|Sr) read_type)clsr,s r) fromstringzType.fromstrings||r+N)r,r-r.r"rE classmethodrdrNr+r)r\r\sM!!![r+r\c@eZdZdZdZejZdZdZdZ dZ dS) ComplexTypect|ts Jd|zt|ts Jd|z||_||_dS)Nz%s is not a Type)r|r\rrrs r)rzComplexType.__init__s\%&&BB(:U(BBBB&$''DD);f)DDDD  r+clt|to|j|jko|j|jkSr)r|rgrrr8s r)r:zComplexType.__eq__s6 uk * * , ek) , u|+ r+ct|tr>|j|jo|j|jS|t kSr)r|rgrmatchesrANY_TYPEr8s r)rkzComplexType.matchessN e[ ) ) $:%%ek22Xt{7J7J5<7X7X X8# #r+c |tkr|St|trT|j|j}|j|j}|r|rt||SdS|tkr|SdSr)rlr|rgrresolver)rr9fr,s r)rnzComplexType.resolves H  K { + +  ""5;//A ##EL11A Q "1a(((t X  L4r+cR|tkr dtzSd|jd|jdS)Nr_rrr )rlrrrs r)rHzComplexType.__str__ s4 8  (? "2tz22DK222 2r+c|tkrtSd|jd|jdS)Nrz -> r)rlr6rrrs r)r6zComplexType.strsL 8  <<>> !Atz~~''AAT[__->->AAA Ar+N) r,r-r.rr:r\rErkrnrHr6rNr+r)rgrgs|    }H$$$   333 BBBBBr+rgc.eZdZdZejZdZdZdS) BasicTypecDt|to d|zd|zkSr^)r|rsr8s r)r:zBasicType.__eq__s$%++O$,0OOr+c$|tkp||kSr)rlr8s r)rkzBasicType.matchess 1DEM1r+c4||r|SdSr)rkr8s r)rnzBasicType.resolves <<   K4r+N)r,r-r.r:r\rErkrnrNr+r)rsrssMPPP}H222r+rsceZdZdZdZdS) EntityTypecdS)NrrNrs r)rHzEntityType.__str__'sr+cdS)NINDrNrs r)r6zEntityType.str*ur+Nr,r-r.rHr6rNr+r)rxrx&s2r+rxceZdZdZdZdS)TruthValueTypecdS)NtrNrs r)rHzTruthValueType.__str__/rzr+cdS)NBOOLrNrs r)r6zTruthValueType.str2svr+Nr~rNr+r)rr.s2r+rceZdZdZdZdS) EventTypecdS)NrUrNrs r)rHzEventType.__str__7rzr+cdS)NEVENTrNrs r)r6z EventType.str:swr+Nr~rNr+r)rr6s2r+rcleZdZdZedZedZdZej Z dZ dZ dZ dZ d S) AnyTypecdSrrNrs r)rzAnyType.__init__?s r+c|SrrNrs r)rz AnyType.firstB r+c|SrrNrs r)rzAnyType.secondFrr+cVt|tp||Sr)r|rr:r8s r)r:zAnyType.__eq__Js#%))?U\\$-?-??r+cdS)NTrNr8s r)rkzAnyType.matchesOstr+c|SrrNr8s r)rnzAnyType.resolveRs r+cdS)N?rNrs r)rHzAnyType.__str__Urzr+cdS)NANYrNrs r)r6z AnyType.strXr}r+N)r,r-r.rpropertyrrr:r\rErkrnrHr6rNr+r)rr>s   XX@@@}Hr+rcht|tsJ|dd}|ddkr|ddksJd}t|D]3\}}|dkr|dz }|dkr|dz}|dksJ%|dkr|dkrn4t t |d|t ||dzdS|dd t zkrt S|dd tzkrtS|dd tzkrtStdd |dz) Nrrrrr rjrr_zUnexpected character: '%s'.) r|r6replacer'rgrb ENTITY_TYPE TRUTH_TYPErlr) type_string paren_countrchars r)rbrbbsn k3 ' ''''%%c2..K1~2#%%%%  --  GAts{{q q "Q!##E k!A#& ' ';q1urz3J)K)K    Q4+- - - Q4*, , , Q4(? * *( /+a.@   r+ceZdZfdZxZS) TypeExceptioncJt|dSrsuperr)rrr!s r)rzTypeException.__init__s! r+r,r-r.r __classcell__r!s@r)rrs8r+rc eZdZdfd ZxZS)"InconsistentTypeHierarchyExceptionNcl|r d|d|d}nd|z}t|dS)NzThe variable 'z8' was found in multiple places with different types in ''.zDThe variable '%s' was found in multiple places with different types.r)rrrrr!s r)rz+InconsistentTypeHierarchyException.__init__s]   &.XXzzz; C %'  r+rrrs@r)rrs=          r+rceZdZfdZxZS)TypeResolutionExceptionc htd|d|jd|ddS)Nz The type of 'z', 'z!', cannot be resolved with type 'r)rrtype)rr other_typer!s r)rz TypeResolutionException.__init__sF zz:???JJJ 8     r+rrs@r)rr8         r+rceZdZfdZxZS)IllegalTypeExceptionc xtd|jjd|d|d|d dS)NzCannot set type of z 'z' to 'z'; must match type 'r)rrr!r,)rrr allowed_typer!s r)rzIllegalTypeException.__init__sS #,,,jjj***lll T     r+rrs@r)rrrr+rc~|D]}||}|ddD]}|||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)r) expressionsrrs r)rrs]"44 ((33 !#2#&(( Y'''' r+ceZdZdZdZdZdS)SubstituteBindingsIzT An interface for classes that can perform substitutions for variables. ct)z :return: The object that is obtained by replacing each variable bound by ``bindings`` with its values. Aliases are already resolved. (maybe?) :rtype: (any) NotImplementedErrorr@s r)rBz'SubstituteBindingsI.substitute_bindings"###r+ct)zB :return: A list of all variables in this object. rrs r) variableszSubstituteBindingsI.variabless"###r+N)r,r-r.r#rBrrNr+r)rrs< $$$$$$$$r+rceZdZdZeZedZed"dZdZ dZ d Z d Z d Z d Zd ZdZdZdZd#dZdZd#dZdZedfdZd$dZd#dZdZdZdZdZdZdZ dZ!dZ"d Z#d!Z$dS)% Expressionz> >T5)))r+cpt|tstd|zt||Sr)r|rr<rr8s r)__or__zExpression.__or__s8%,, ?5=>> >D%(((r+cpt|tstd|zt||Sr)r|rr<rr8s r)__gt__zExpression.__gt__rr+cpt|tstd|zt||Sr)r|rr<rr8s r)r=zExpression.__lt__rr+ctSr)NotImplementedr8s r)r:zExpression.__eq__sr+c:tt|Sr)rDreprrs r)rEzExpression.__hash__sDJJr+ct|ts Jd|z|ddlm}|}t ||}||S)a9 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 ``Expression`` to check equality against :param prover: a ``nltk.inference.api.Prover`` rNr)Prover9)r|rnltk.inferencerrsimplifyprove)rr9proverrbiconds r)equivzExpression.equivs}%,,OO.G%.OOOO > . . . . . .WYYFt}}0@0@AA||F###r+cr|}|D]}||vr||}t|tr||}n't|tst d|||}|||d}|S)Nz>Can not substitute a non-expression value into an expression: T alpha_convert) rr|rrrr+rBrr)rrAexprvarvals r)rBzExpression.substitute_bindingss>>## B BChsmc8,,66s;;CC#C44$*:=#@ --h77||CD|AA}}r+cbtt|ru|D]r}||}tt|}t |t r||_nt||_||s| fdDS)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 )rc8i|]}||djS)r)r)r'keysigs r) z(Expression.typecheck..=s&555#SXa[%555r+) rrrrr|r\rrbr _set_type)rrrrvarExrs @r)rzExpression.typecheck(s$  '  ' 'n*8C==99c4((0!$EJJ!*3EJC&&&& %%%55555555r+ct)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 rrrs r)findtypezExpression.findtype?rr+ct)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)) rrrrs r)rzExpression._set_typeHs"###r+ctts Jdztts Jdz|fd|jS)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? %s is not a Variablerc4|Sr)r)rrr replace_boundrs r)z$Expression.replace..`saii*m]SSr+)r|rrvisit_structuredr!rrrrrs ````r)rzExpression.replaceRs(H--PP/E/PPPP*j11  % 2   $$ S S S S S S S N   r+cfd|}tt|dD]\}}t|tr)|t d|dzz}n@t|t r)|t d|dzz}n|}||j|d}|S)z&Rename auto-generated unique variablesct|tr|hSt|trtS|dS)NcPttj|tSrroperatoror_setpartss r)rz>Expression.normalize..get_indiv_vars..ns&ucee2T2Tr+)r|IndividualVariableExpressionAbstractVariableExpressionrvisit)rget_indiv_varss r)r z,Expression.normalize..get_indiv_varsgsX!9:: s A9:: uu ww"$T$Tr+c|jSrrrs r)rz&Expression.normalize..rsr+)rze0%srjzz%sT) r'sortedr|EventVariableExpressionr!rrrr)rnewvarsrrrnewVarr s @r) normalizezExpression.normalizeds     f^^D%9%9?S?STTTUU > >DAq!455 XfA.>%?%?@@A;<< Xeq1uo%>%>??^^AJ==FF r+ct)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`` rrr combinators r)r zExpression.visit|s"###r+c6||fdS)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 c|SrrN)rrs r)rz-Expression.visit_structured..s**e2Dr+r rs `r)rzExpression.visit_structureds#zz($D$D$D$DEEEr+c(d|jjd|dS)Nrrr )r!r,rs r)r"zExpression.__repr__s 44>*44T4444r+c*|Sr)r6rs r)rHzExpression.__str__sxxzzr+c|d||zDzS)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 cFh|]}tjd|j|S)z^[?@])r$r%r)r'ps r) z'Expression.variables..s=   rxQRQW?X?X    r+)free predicates constantsrs r)rzExpression.variablessNyy{{  ((4>>+;+;;     r+c2|ddS)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 c*|Sr)rr s r)rz!Expression.free..saffhhr+cPttj|tSrrrs r)rz!Expression.free..sfX\5#%%.P.Pr+rrs r)rzExpression.frees& zz   P P   r+c2|ddS)zu Return a set of individual constants (non-predicates). :return: set of ``Variable`` objects c*|Sr)r!r s r)rz&Expression.constants..sakkmmr+cPttj|tSrrrs r)rz&Expression.constants..s6(,suu3U3Ur+rrs r)r!zExpression.constantss& zz # #%U%U   r+c2|ddS)zu Return a set of predicates (constants, not variables). :return: set of ``Variable`` objects c*|Sr)r r s r)rz'Expression.predicates..sallnnr+cPttj|tSrrrs r)rz'Expression.predicates..sF8<PSPUPU4V4Vr+rrs r)r zExpression.predicatess& zz $ $&V&V   r+c:|d|jS)zD :return: beta-converted version of this expression c*|Sr)rr s r)rz%Expression.simplify..sqzz||r+)rr!rs r)rzExpression.simplifys $$%;%;T^LLLr+c t|Sr)rrs r)rz"Expression.make_VariableExpressions!(+++r+)FNrFT)%r,r-r.r#rfrrrerdrrrrrrrr=r:rErrBrrrlrrrr rr"rHrrr!r rrrNr+r)rrsFFKMMM"-+">">">999[9  222''' *** ))) *** ***    $$$$$$6666.$$$$,t$$$$    $0$$$" F F F555             MMM ,,,,,r+ri'cd}|g}|rT|}|dz }||krdSt|ts||jd|TdS)aReturn ``True`` if ``expression`` has more than ``limit`` subexpressions. Counts iteratively (so deep expressions can't overflow the stack) and stops as soon as the limit is passed, so the check costs ``O(limit)`` even for an exponentially large expression. rrjTcdSrrNrs r)rz_exceeds_size..s4r+F)rr|rr r)rlimitcountstacknodes r) _exceeds_sizer5s| E LE 9yy{{   5==4$ :;; 9 JJu|%7%7 8 8 8 9 5r+ceZdZdZdZdZedZedfdZ dZ dZ d Z d Z d ZejZd Zd ZedZedZdZdS)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)". ct|ts Jd|zt|ts Jd|z||_||_dS)z :param function: ``Expression``, for the function expression :param argument: ``Expression``, for the argument rN)r|rrrr s r)rzApplicationExpression.__init__s^ (J//UU1JX1UUUU(J//UU1JX1UUUU    r+c|j}|j}t|trc|j|j|d}t|trtdtd|S| ||S)NTrz;Refusing to beta-reduce: result exceeds MAX_SIMPLIFY_SIZE (z}) subexpressions; the expression may cause exponential blow-up (CWE-400). Raise nltk.sem.logic.MAX_SIMPLIFY_SIZE to allow it.) rrrr|r rrrr5MAX_SIMPLIFY_SIZEr+r!)rrrrs r)rzApplicationExpression.simplifys=))++=))++ h 0 1 1 6]**!84+FV%677  E)EEE ??$$ $>>(H55 5r+cpt|jjtr|jjjSt Sr)r|rrrgrrlrs r)rzApplicationExpression.type5s, dm(+ 6 6 =%, ,Or+Nct|tsJ|tt}|jt | |jt|jj ||dS#t$rR}td|jd|jj d|jd|jj d|jj j d |d}~wwxYw):see Expression._set_type()NzThe function 'z' is of type 'z' and cannot be applied to 'z ' of type 'z"'. Its argument must match type 'r) r|r\rrrrrlrrgrrrr)rrrrs r)rzApplicationExpression._set_type<s*d+++++  #D))I )444  M # #DM. ;;Y     '   -MMMM&&&MMMM&&&M&,,,    s3B C A CC ctts Jdz|r|\}}n|j}|jg}fd|g|zD}g}|D]A}|t kr4|r|D]}||rn,||Bt|dkrt|dSt S):see Expression.findtype()rc:g|]}|SrN)r)r'argrs r)r*z2ApplicationExpression.findtype.._s%EEECh''EEEr+rjr) r|ris_atomuncurryrrrlrkrrr)rrrargsfounduniquerous ` r)rzApplicationExpression.findtypeUs(H--PP/E/PPPP <<>> #!\\^^NHdd}HM?DEEEEH:3DEEE % %AH}}%#""99Q<<"!E"MM!$$$ v;;!  <<? "Or+ct|jtrt}n|j}||jzSz:see: Expression.constants())r|rrrr!r)rfunction_constantss r)r!zApplicationExpression.constantspsQ dm%? @ @ ;!$  !%!8!8!:!: !DM$;$;$=$===r+ct|jtr|jjh}n|j}||jzSz:see: Expression.predicates())r|rrrr r)rfunction_predss r)r z ApplicationExpression.predicatesxsR dm%7 8 8 8"m45NN!]5577N 8 8 : :::r+cT|||j||jgSz:see: Expression.visit())rrrs r)r zApplicationExpression.visits/z88DM22HHT]4K4KLMMMr+clt|to|j|jko|j|jkSr)r|r rrr8s r)r:zApplicationExpression.__eq__s7 u3 4 4 0 / 0 / r+cL|r7|\}}dd|D}n|j}d|jz}d|z}d}t |t rYt |jtr"t |jjtsd}n4t |jtsd}nt |trd}|rtj |ztj z}|tj z|ztj zS)Nrc3 K|] }d|zV dSr_NrN)r'r@s r) z0ApplicationExpression.__str__..s&::ctcz::::::r+r_FT)rArBjoinrrr|r rr rBooleanExpressionr r8r9)rrrCarg_str function_strparenthesize_functions r)rHzApplicationExpression.__str__s <<>> +!\\^^NHdhh::T:::::GG}HT]*Gh % h 0 1 1 )(-)>?? -!(-"8:TUU1,0) /@AA -(,% "7 8 8 )$( !  E!;5 DLfk)G3flBBr+c|j}|jg}t|tr7|d|j|j}t|t7||fS)zh Uncurry this application expression return: A tuple (base-function, arg-list) r)rrr|r insert)rrrCs r)rBzApplicationExpression.uncurrysh = #899 ) KK8, - - -(H#899 )$r+c6|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. rrBrs r)predzApplicationExpression.preds||~~a  r+c6|dS)z+ Return uncurried arg-list rjr\rs r)rCzApplicationExpression.argss ||~~a  r+c6t|jtS)zk Is this expression an atom (as opposed to a lambda expression applied to a term)? )r|r]rrs r)rAzApplicationExpression.is_atoms $)%?@@@r+)r,r-r.r#rrrrrlrrr!r r r:rrErHrBr]rCrArNr+r)r r s58!!!6662X $,t26>>>;;;NNN   "HCCC4    !!X!!!X! AAAAAr+r c^eZdZdZdZdZddZedfdZd Z d Z d Z d Z e jZd ZdS)rzDThis class represents a variable to be used as a predicate or entitycXt|ts Jd|z||_dS)zA :param variable: ``Variable``, for the variable rN)r|rrrs r)rz#AbstractVariableExpression.__init__s3(H--PP/E/PPPP  r+c|SrrNrs r)rz#AbstractVariableExpression.simplifys r+FTct|ts Jd|zt|ts Jd|z|j|kr|S|S):see: Expression.replace()z%s is not an Variabler)r|rrrrs r)rz"AbstractVariableExpression.replacesn(H--QQ/F/QQQQ*j11  % 2    =H $ $ Kr+Ncft|tsJ|tt}|}||jjD]-}|j|}|st|.||jj |||jjD] }||_ dSr<N) r|r\rrrrrrnrrrrr resolutionrs r)rz$AbstractVariableExpression._set_types*d+++++  #D))I t}12 ? ?E++J77J ?8>>> ? $-$%,,T222t}12 $ $E#EJJ $ $r+cxt|ts Jd|z|j|kr|jStSr>r)r|rrrrlrs r)rz#AbstractVariableExpression.findtypes@(H--PP/E/PPPP =H $ $9 Or+ctSrKrrs r)r z%AbstractVariableExpression.predicates uu r+cLt|to|j|jkS)zTAllow equality between instances of ``AbstractVariableExpression`` subtypes.)r|rrr8s r)r:z!AbstractVariableExpression.__eq__s( u8 9 9 0 / r+cZt|tst|j|jkSr)r|rr<rr8s r)r=z!AbstractVariableExpression.__lt__ s)%!;<< O}u~--r+cd|jzSr^r rs r)rHz"AbstractVariableExpression.__str__sdm##r+r.)r,r-r.r#rrrrlrrr r:r=rrErHrNr+r)rrsNN!!!    $,t$$$$"   ... "H$$$$$r+rcHeZdZdZedfdZdZeeeZdZ dZ dS)rzThis class represents variables that take the form of a single lowercase character (other than 'e') followed by zero or more digits.Nc t|tsJ|tt}|t st ||t ||jj |dSrf) r|r\rrrkrrrrrrs r)rz&IndividualVariableExpression._set_typesx*d+++++  #D))I!!+.. F&tZEE E$-$%,,T22222r+ctSr)rrs r) _get_typez&IndividualVariableExpression._get_type&sr+c|jhSz:see: Expression.free()r rs r)rz!IndividualVariableExpression.free+  r+ctSrHrlrs r)r!z&IndividualVariableExpression.constants/rmr+) r,r-r.r#rlrrtrrrr!rNr+r)rrs{CC$,t 3 3 3 3 8Iy ) )Dr+rc"eZdZdZeZdZdZdS)rzwThis class represents variables that take the form of a single uppercase character followed by zero or more digits.c|jhSrvr rs r)rzFunctionVariableExpression.free:rwr+ctSrHrlrs r)r!z$FunctionVariableExpression.constants>rmr+N)r,r-r.r#rlrrr!rNr+r)rr4sC22 Dr+rceZdZdZeZdS)rz{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_TYPErrNr+r)rrCs66 DDDr+rc.eZdZdZeZedfdZdZdZ dS)rztThis class represents variables that do not take the form of a single character followed by zero or more digits.Nct|tsJ|tt}|tkrt }n,|}|jt kr||j}||jj D]-}|j|}|st|.||jj  |||jj D] }||_ dSrf) r|r\rrrlrrrnrrrrrgs r)rzConstantExpression._set_typePs*d+++++  #D))I  ! !$JJ#JyK'''// :: t}12 ? ?E++J77J ?8>>> ? $-$%,,T222t}12 $ $E#EJJ $ $r+ctSrvrlrs r)rzConstantExpression.freehrmr+c|jhSrHr rs r)r!zConstantExpression.constantslrwr+) r,r-r.r#rrrlrrr!rNr+r)rrJs\22 D#+t$$$$0r+rc6t|ts Jd|zt|jrt |St |jrt |St|jrt|St|S)z This is a factory method that instantiates and returns a subtype of ``AbstractVariableExpression`` appropriate for the given variable. r) r|rrNrrrOrrPrrr s r)rrqs h ) )LL+AH+LLLL,+H555 HM " ",)(333 X] # #,&x000!(+++r+cReZdZdZdZd dZdZdZdZd Z d Z d Z e j Z d S)VariableBinderExpressionzThis an abstract class for any Expression that binds a variable in an Expression. This includes LambdaExpressions and Quantified Expressionsct|ts Jd|zt|ts Jd|z||_||_dS)zs :param variable: ``Variable``, for the variable :param term: ``Expression``, for the term rrN)r|rrrrrs r)rz!VariableBinderExpression.__init__s^ (H--PP/E/PPPP$ ++MM-F-MMMM   r+FTc Nt|ts Jd|zt|ts Jd|z|j|kr\|rXt|ts Jd|z||j|j||d|S|S|rC|j|vr(| t|j}||j|j||||S)rdrrz&%s is not a AbstractVariableExpressionT)rR) r|rrrrr!rrrrrVrs r)rz VariableBinderExpression.replacesO(H--PP/E/PPPP*j11  % 2    =H $ $ !*.HII>  !!(J }UU r+c t|ts Jd|z|||j|jt |dS)zRename all occurrences of the variable introduced by this variable binder in the expression to ``newvar``. :param newvar: ``Variable``, for the new variable rT)r|rr!rrrr)rnewvars r)rz&VariableBinderExpression.alpha_convertsc &(++LL-Cf-LLLL~~ DI%%dm5G5O5OQUVV   r+cF|j|jhz Srv)rrrrs r)rzVariableBinderExpression.freesy~~4=/11r+ct|ts Jd|z||jkrtS|j|Srj)r|rrrlrrrs r)rz!VariableBinderExpression.findtypesN(H--PP/E/PPPP t} $ $O9%%h// /r+c6|||jgSrNrrs r)r zVariableBinderExpression.visit!z88DI../000r+c@||j||jS)z#:see: Expression.visit_structured())rrrs r)rz)VariableBinderExpression.visit_structureds"z$-$))<)<===r+ct||jst||jr]|j|jkr|j|jkSt |j}|j|j|j|kSdS)z~Defines equality modulo alphabetic variance. If we are comparing \x.M and \y.N, then check equality of M and N[x/y].F)r|r!rrrr)rr9varexs r)r:zVariableBinderExpression.__eq__s dEO , ,  5$.0Q0Q }..yEJ..+4=99yEJ$6$6u~u$M$MMM5r+Nr.)r,r-r.r#rrrrrr rr:rrErNr+r)rrsOO<   222000111>>>   "HHHr+rc6eZdZedZedfdZdZdS)r cpt|j|j|jjSr)rgrrrrrs r)rzLambdaExpression.types(49--dm<.&33Atax333333r+r_)rrr!rr r/rTr7rrrs r)rHzLambdaExpression.__str__s]O yn..   T] + + +9Dn.. Mhh3333333 4j Tk  r+r,r-r.rrrlrrHrNr+r)r r sZ NNXN$,t < < < <      r+r c6eZdZedZedfdZdZdS)QuantifiedExpressionctSrrrs r)rzQuantifiedExpression.typer+Nct|tsJ|tt}|t st ||t |jt |dSrf r|r\rrrkrrrrrs r)rzQuantifiedExpression._set_typer*d+++++  #D))I!!*-- E&tZDD D J 22222r+c6|jg}|j}|j|jkr1||j|j}|j|jk1|dzdd|Dzt jzd|zzS)Nrc3 K|] }d|zV dSrRrNrs r)rSz/QuantifiedExpression.__str__..rr+r_)rrr!r getQuantifierrTr r7rs r)rHzQuantifiedExpression.__str__ s]O yn..   T] + + +9Dn..     hh3333333 4j Tk   r+rrNr+r)rrsW X$,t 3 3 3 3      r+rceZdZdZdS)rctjSr)r r1rs r)rzExistsExpression.getQuantifiers }r+Nr,r-r.rrNr+r)rrs#r+rceZdZdZdS)rctjSr)r r3rs r)rzAllExpression.getQuantifier zr+NrrNr+r)rrs#r+rceZdZdZdS)rctjSr)r r5rs r)rzIotaExpression.getQuantifier#s {r+NrrNr+r)rr"s#r+rcbeZdZdZedZedfdZdZdZ dZ dZ e j Z d ZdS) rcXt|ts Jd|z||_dSr)r|rr)rrs r)rzNegatedExpression.__init__(s1$ ++MM-F-MMMM r+ctSrrrs r)rzNegatedExpression.type,rr+Nct|tsJ|tt}|t st ||t |jt |dSrfrrs r)rzNegatedExpression._set_type0rr+czt|ts Jd|z|j|S)Nr)r|rrrrs r)rzNegatedExpression.findtype;s<(H--PP/E/PPPPy!!(+++r+c6|||jgSrNrrs r)r zNegatedExpression.visit?rr+c|jS)z:see: Expression.negate()rrs r)rzNegatedExpression.negateCs yr+cLt|to|j|jkSr)r|rrr8s r)r:zNegatedExpression.__eq__Gs!%!233O UZ8OOr+c0tjd|jzzSr^)r r;rrs r)rHzNegatedExpression.__str__LszD49,,,r+)r,r-r.rrrrlrrr rr:rrErHrNr+r)rr'sX$,t 3 3 3 3,,,111PPP"H-----r+rcVeZdZdZedZdZdZdZe j Z dZ dZ dS) BinaryExpressionct|ts Jd|zt|ts Jd|z||_||_dSr)r|rrrrs r)rzBinaryExpression.__init__Qs\%,,OO.G%.OOOO&*--QQ/H6/QQQQ  r+ctSrrrs r)rzBinaryExpression.typeWrr+ct|ts Jd|z|j|}|j|}||ks |t kr|S|t kr|St Srj)r|rrrrrl)rrror,s r)rzBinaryExpression.findtype[sy(H--PP/E/PPPP J   ) ) K  * * 66Q(]]H (]]HOr+cT|||j||jgSrN)rrrs r)r zBinaryExpression.visitgs/z88DJ//$+1F1FGHHHr+ct||jst||jo|j|jko|j|jkSr)r|r!rrr8s r)r:zBinaryExpression.__eq__ksI eo . . S*UDN2S2S , ek) , u|+ r+c||j}||j}tj|zdz|zdz|ztjzS)Nr) _str_subexrrr r8getOpr9rs r)rHzBinaryExpression.__str__tsX ++--{U"S(4::<<7#=FUUr+c d|zSr^rN)rsubexs r)rzBinaryExpression._str_subexys e|r+N) r,r-r.rrrrr r:rrErHrrNr+r)rrPs X   III   "HVVV r+rceZdZedfdZdS)rUNc@t|tsJ|tt}|t st ||t |jt ||j t |dSrf) r|r\rrrkrrrrrrs r)rzBooleanExpression._set_type~s*d+++++  #D))I!!*-- E&tZDD D Z333 j)44444r+)r,r-r.rlrrNr+r)rUrU}s-#+t 5 5 5 5 5 5r+rUceZdZdZdZdZdS)rz"This class represents conjunctionsctjSr)r r=rs r)rzAndExpression.getOprr+cNd|z}t|tr |ddS|SNr_rjr)r|rrrr,s r)rzAndExpression._str_subexs/ 5L e] + + QrT7Nr+Nr,r-r.r#rrrNr+r)rrs8,,r+rceZdZdZdZdZdS)rz"This class represents disjunctionsctjSr)r r?rs r)rzOrExpression.getOp yr+cNd|z}t|tr |ddS|Sr)r|rrs r)rzOrExpression._str_subexs/ 5L e\ * * QrT7Nr+NrrNr+r)rrs8,,r+rceZdZdZdZdS)rz"This class represents implicationsctjSr)r rArs r)rzImpExpression.getOprr+Nr,r-r.r#rrNr+r)rrs),,r+rceZdZdZdZdS)rz$This class represents biconditionalsctjSr)r rCrs r)rzIffExpression.getOprr+NrrNr+r)rrs)..r+rc$eZdZdZedfdZdZdS)rz:This class represents equality expressions like "(x = y)".Nc@t|tsJ|tt}|t st ||t |jt||j t|dSrf) r|r\rrrkrrrrrrrs r)rzEqualityExpression._set_types*d+++++  #D))I!!*-- E&tZDD D [)444 k955555r+ctjSr)r rErs r)rzEqualityExpression.getOprr+)r,r-r.r#rlrrrNr+r)rrsBDD#+t 6 6 6 6r+rceZdZdZdS)rcJ||_t||dSr)r Exceptionrrrrs r)rz#LogicalExpressionException.__init__s% 4)))))r+Nr,r-r.rrNr+r)rrs#*****r+rceZdZddZdS)rNc|r |r d|d|d}n|rd|z}|r|d|zz }nd|z}t|||dS)NzUnexpected token: 'z'. Expected token 'rzUnexpected token: '%s'.z rrr)rr unexpectedrrrs r)rz!UnexpectedTokenException.__init__s  4( 4 4 CC 4+j8C &tg~%(83C"++D%=====r+)NNNrrNr+r)rrs( > > > > > >r+rceZdZddZdS)rNcL|sd}t||d|zdS)NzMore tokens expected.zEnd of input found. rrs r)rz$ExpectedMoreTokensException.__init__s> .-G"++ %07:     r+rrrNr+r)rrs(      r+rctt|ts Jd|ztjd|duS)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 r5z ^[a-df-z]\d*$Nr|r6r$r%rs r)rNrNs@ dC =="6"==== 8$d + +4 77r+ctt|ts Jd|ztjd|duS)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 r5z ^[A-Z]\d*$Nrrs r)rOrOs? dC =="6"==== 8M4 ( ( 44r+ctt|ts Jd|ztjd|duS)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 r5z^e\d*$Nrrs r)rPrPs? dC =="6"==== 8It $ $D 00r+cTtj}tdt|dt|dt|dt|dt|dt|dt|dt|d t|d t|d t|d t|d t|dt|dt|dtdt|dt|dt|dt|dtd|d}t||t d}t|t||kdS)Nz3====================Test reader====================johnzman(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)rK)rrdrWrrr)lexpre1e2s r)demor s  !E -... %%.. %%   %%   %%0 1 1222 %%9 : :;;; %%   %%" # #$$$ %%! " "### %%& ' '((( %%. / /000 %%! " "### %%# $ $%%% %%# $ $%%% %%. / /000 %%% & &''' /000 %%. / / 8 8 : :;;; %%. / / 8 8 : :;;; %%? @ @ I I K KLLL %%H I I R R T TUUU VWWW   B "III  (3-- ( (B "III "(OOOOOr+ctdtdtdtdtdtdtdtdtd td td td td tddS)Nz:====================Test reader errors====================z (P(x) & Q(x)z((P(x) &) & Q(x))zP(x) -> zP(xzP(x,zP(x,)r z exists x.r z\ x y.zP(x)Q(x)z (P(x)Q(x)z exists x -> y)rW demoExceptionrNr+r) demo_errorsr-s 4555.!!!%&&&*%&'(+$)*+/"""""r+c t|dS#t$r)}t|jjd|Yd}~dSd}~wwxYw)Nr)rrdrrWr!r,)r,rs r)rr>ss.a     %... %,,,,---------.s AA  Ac\t|d|jdS)Nz : )rWr6r)exs r) printtyperEs. RVVXX # #"' # #$$$$$r+__main__)NNr)Mr#rr$ collectionsr functoolsrrnltk.internalsr nltk.utilrrrQr r[r_rdrfr2rrVrZr\rgrsrxrrrrrr}rlrbrrrrrrrrr9r5r rrrrrrrr rrrrrrrUrrrrrrrrrNrOrPrrrrr,rNr+r)rs  ######,,,,,,,,""""""  799*I*I*I*I*I*I*I*IZ"""""""""N@N@N@N@N@N@N@N@b<,,,,,,,,:    8            /B/B/B/B/B$/B/B/Bd         Y i<^   jll Y[[ 799   >I             m        =        $$$$$$$$,E,E,E,E,E,$E,E,E,d*UAUAUAUAUAJUAUAUApE$E$E$E$E$E$E$E$P#=<     !;   :$$$$$3$$$N , , , W#W#W#W#W#zW#W#W#t     /   <     3   >+ ( ) &-&-&-&-&- &-&-&-R*****z***Z 5 5 5 5 5( 5 5 5     %        $   %%),******** > > > > >9 > > >      "<    8 8 8 5 5 5 1 1 1B###"...%%% zDFFFFFr+