'[f_dZddlZddlZddlmZddlmZmZddlm Z ddl m Z dZ e Z Gdd Zd Zd Zd ZGd dZdgdZeGddZdgdZdhdZGddZGddeZGddeZGddeZGddeZGddeZGd d!eeZeZeZeZ eZ!d"Z"Gd#d$e#Z$Gd%d&e$Z%Gd'd(e$Z&Gd)d*e$Z'dhd+Z(Gd,d-Z)Gd.d/e)Z*Gd0d1e*Z+eGd2d3e*Z,Gd4d5e,Z-Gd6d7e,Z.Gd8d9e-Z/Gd:d;e,Z0d<Z1Gd=d>e*Z2Gd?d@e2Z3GdAdBe2Z4GdCdDe4Z5GdEdFe4Z6GdGdHe4Z7GdIdJe*Z8GdKdLe*Z9GdMdNe9Z:GdOdPe:Z;GdQdRe:Z<GdSdTe:Z=GdUdVe:Z>GdWdXe9Z?GdYdZe#Z@Gd[d\e@ZAGd]d^e@ZBd_ZCd`ZDdaZEdbZFdcZGddZHdeZIeJdfkr eFdSdS)izV 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 B/var/www/piapp/venv/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+ceZdZdZd%dZd&dZdZdZdZd Z d&d Z d Z d Z d Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$dS)' LogicParserz$A lambda calculus expression parser.FcRt|tsJd|_g|_||_ g|_t dtjDdtj Dztdfgzdtj tj zDzdtj DzdtjDzdtjDzd 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__..rlr+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..s...!1v...r+cg|]}|dfS)rNr&s r)r*z(LogicParser.__init__..rlr+cg|]}|dfS) rNr&s r)r*z(LogicParser.__init__..rlr+)N N) isinstancebool _currentIndex_buffer type_check quote_charsdictr r0r<rrFrHrJr>r@rBrDoperator_precedenceright_associated_operations)selfrs r)__init__zLogicParser.__init__fsN *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}|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 rNriz {} {} {}^ ) rstripr}processr~process_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 C9CCcg}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 ri)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)Nrriz: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_symbolss ~r+cB|j|zt|jkS)z6Return TRUE if the given location is within the buffer)r}rr~)rlocations r)rzLogicParser.inRanges!H,s4 A%A  A%c|tjvSN)r rLrrs r) isvariablezLogicParser.isvariables&-''r+c |}n,#t$r}t|jdzd|d}~wwxYw|||}|st |j|d|||S)zAParse the next complete expression from the stream and return it.riExpression expected.messageN)rrr}handlerattempt_adjuncts)rcontextrraccums r)rz#LogicParser.process_next_expressions **,,CC*   -"Q&0F    C)) *"C1G $$UG444 A;Ac||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.handle+s ??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_adjuncts=st+++(G88WMMJ;;JPPJ77 GLLJ +++ r+cf||tjSr)make_NegatedExpressionrr r;rs r)rzLogicParser.handle_negationFs&**4+G+G +S+STTTr+c t|SrNegatedExpression)rrs r)rz"LogicParser.make_NegatedExpressionIs ,,,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_variableLsq,,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_variablejs 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) Nrrkz;Variable and Expression expected following lambda operator.r abstractedTrir) rrr}rrr r7rrrmake_LambdaExpressionpop)rrrvarsrs r)rzLogicParser.handle_lambdaws}||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) Nrrkz;Variable and Expression expected following quantifier '%s'.r quantifiedTrir) 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_ApplicationExpressions   S' * * ||A 4::a==FK#?#?":/?@@ &z3HII 'z3MNN 'z3EFF  5*+j8.. 77 < )rr __class__r,)rrs r)__repr__zLogicParser.__repr__GsN <<?? # 4::a==0CC"CT^,,t3c9C??r+)Fr)%r,r-r.__doc__rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrNr+r)rfrfcs1..#1#1#1#1J6444l"""HAAA M M M M(((555$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_logicr/Os HHX  "}} J"1<<>>22OO zz|| ??3   42::  O   l0066 7 7 7 7) O O OFWFFFFGGQ N O s(B** C4C  Cc>eZdZdZdZdZdZdZdZdZ dZ d S) rcXt|ts Jd|z||_dS)z7 :param name: the name of the variable %s is not a stringN)r{strrrs r)rzVariable.__init__os3$$$AA&:T&AAAA r+cLt|to|j|jkSr)r{rrrothers r)__eq__zVariable.__eq__vs %**FtyEJ/FFr+c||k SrrNr5s r)__ne__zVariable.__ne__y5=  r+cZt|tst|j|jkSr)r{r TypeErrorrr5s 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)rzVariable.__repr__s$)++r+N) r,r-r.rr7r9r=rBrErHrrNr+r)rrmsGGG!!!&&& (((,,,,,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)rz 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.rrE classmethodrdrNr+r)r\r\sM!!![r+r\cFeZdZdZdZdZejZdZdZ dZ 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{rgrrr5s r)r7zComplexType.__eq__s6 uk * * , ek) , u|+ r+c||k SrrNr5s r)r9zComplexType.__ne__r:r+ct|tr>|j|jo|j|jS|t kSr)r{rgrmatchesrANY_TYPEr5s r)rlzComplexType.matchessN e[ ) ) $:%%ek22Xt{7J7J5<7X7X X8# #r+c |tkr|St|trT|j|j}|j|j}|r|rt||SdS|tkr|SdSr)rmr{rgrresolver)rr6fr)s r)rozComplexType.resolves H  K { + +  ""5;//A ##EL11A Q "1a(((t X  L4r+cR|tkr dtzSd|jd|jdS)Nr_rrr)rmrrrs r)rHzComplexType.__str__s4 8  (? "2tz22DK222 2r+c|tkrtSd|jd|jdS)Nrz -> r)rmr3rrrs r)r3zComplexType.strsL 8  <<>> !Atz~~''AAT[__->->AAA Ar+N) r,r-r.rr7r9r\rErlrorHr3rNr+r)rgrgs    !!!}H$$$   333 BBBBBr+rgc4eZdZdZdZejZdZdZdS) BasicTypecDt|to d|zd|zkSr^)r{rtr5s r)r7zBasicType.__eq__s$%++O$,0OOr+c||k SrrNr5s r)r9zBasicType.__ne__r:r+c$|tkp||kSr)rmr5s r)rlzBasicType.matchess 1DEM1r+c4||r|SdSr)rlr5s r)rozBasicType.resolves <<   K4r+N) r,r-r.r7r9r\rErlrorNr+r)rtrts\PPP!!!}H222r+rtceZdZdZdZdS) EntityTypecdS)NrrNrs r)rHzEntityType.__str__ sr+cdS)NINDrNrs r)r3zEntityType.strur+Nr,r-r.rHr3rNr+r)rzrz s2r+rzceZdZdZdZdS)TruthValueTypecdS)NtrNrs r)rHzTruthValueType.__str__r|r+cdS)NBOOLrNrs r)r3zTruthValueType.strsvr+NrrNr+r)rrs2r+rceZdZdZdZdS) EventTypecdS)NrUrNrs r)rHzEventType.__str__r|r+cdS)NEVENTrNrs r)r3z EventType.strswr+NrrNr+r)rrs2r+rcreZdZdZedZedZdZdZe j Z dZ dZ dZ d Zd S) AnyTypecdSrrNrs r)rzAnyType.__init__#s r+c|SrrNrs r)rz AnyType.first& r+c|SrrNrs r)rzAnyType.second*rr+cVt|tp||Sr)r{rr7r5s r)r7zAnyType.__eq__.s#%))?U\\$-?-??r+c||k SrrNr5s r)r9zAnyType.__ne__1r:r+cdS)NTrNr5s r)rlzAnyType.matches6str+c|SrrNr5s r)rozAnyType.resolve9s r+cdS)N?rNrs r)rHzAnyType.__str__<r|r+cdS)NANYrNrs r)r3z AnyType.str?rr+N)r,r-r.rpropertyrrr7r9r\rErlrorHr3rNr+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) Nrrrrrrirr_zUnexpected character: '%s'.) r{r3replacer$rgrb ENTITY_TYPE TRUTH_TYPErmr) type_string paren_countrchars r)rbrbIsn k3 ' ''''%%c2..K1~2#%%%%  --  GAts{{q q "Q!##E k!A#& ' ';q1urz3J)K)K    Q4+- - - Q4*, , , Q4(? * *( /+a.@   r+ceZdZfdZxZS) TypeExceptioncJt|dSrsuperr)rrrs r)rzTypeException.__init__is! r+r,r-r.r __classcell__rs@r)rrhs8r+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)rrrrrs r)rz+InconsistentTypeHierarchyException.__init__ns]   &.XXzzz; C %'  r+rrrs@r)rrms=          r+rceZdZfdZxZS)TypeResolutionExceptionc htd|d|jd|ddS)Nz The type of 'z', 'z!', cannot be resolved with type 'r)rrtype)rr other_typers r)rz TypeResolutionException.__init__}sF zz:???JJJ 8     r+rrs@r)rr|8         r+rceZdZfdZxZS)IllegalTypeExceptionc xtd|jjd|d|d|d dS)NzCannot set type of z 'z' to 'z'; must match type 'r)rrrr,)rrr allowed_typers 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+rc eZdZdZeZedZed#dZdZ dZ d Z d Z d Z d Zd ZdZdZdZd$dZdZdZd$dZdZedfdZd%dZd$dZdZdZdZdZdZ dZ!dZ"d Z#d!Z$d"Z%dS)& Expressionz> >T5)))r+cpt|tstd|zt||Sr)r{rr<rr5s r)__or__zExpression.__or__s8%,, ?5=>> >D%(((r+cpt|tstd|zt||Sr)r{rr<rr5s r)__gt__zExpression.__gt__rr+cpt|tstd|zt||Sr)r{rr<rr5s r)r=zExpression.__lt__rr+ctSr)NotImplementedr5s r)r7zExpression.__eq__sr+c||k SrrNr5s r)r9zExpression.__ne__r:r+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)rr6proverrbiconds r)equivzExpression.equivs}%,,OO.G%.OOOO > . . . . . .WYYFt}}0@0@AA||F###r+c:tt|Sr)rDreprrs r)rEzExpression.__hash__sDJJr+cn|}|D]}||vr||}t|tr||}n't|tst d|||}|||}|S)Nz>Can not substitute a non-expression value into an expression: ) rr{rrrr(rBrr)rrAexprvarvals r)rBzExpression.substitute_bindingss>>## . .Chsmc8,,66s;;CC#C44$*:=#@ --h77||C--}}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.typechecks$  '  ' '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_type2s"###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)r alpha_convertr replace_boundrs r)z$Expression.replace..Jsaii*m]SSr+)r{rrvisit_structuredrrrrrrs ````r)rzExpression.replace<s(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..Xs&ucee2T2Tr+)r{IndividualVariableExpressionAbstractVariableExpressionrvisit)rget_indiv_varss r)r z,Expression.normalize..get_indiv_varsQsX!9:: s A9:: uu ww"$T$Tr+c|jSrrrs r)rz&Expression.normalize..\sr+)rze0%srizz%sT) r$sortedr{EventVariableExpressionrrr rr)rnewvarsrrrnewVarr s @r) normalizezExpression.normalizeNs     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.visitfs"###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)r rs r)rz-Expression.visit_structured..s**e2Dr+r rs `r)rzExpression.visit_structuredws#zz($D$D$D$DEEEr+c(d|jjd|dS)Nrrr)rr,rs r)rzExpression.__repr__s 44>*44T4444r+c*|Sr)r3rs 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)r"rs r)rz!Expression.free..saffhhr+cPttj|tSrrrs r)rz!Expression.free..sfX\5#%%.P.Pr+rrs r)r"zExpression.frees& zz   P P   r+c2|ddS)zu Return a set of individual constants (non-predicates). :return: set of ``Variable`` objects c*|Sr)r$rs 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#rs 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)rrs r)rz%Expression.simplify..sqzz||r+)rrrs r)rzExpression.simplifys $$%;%;T^LLLr+c t|Sr)rrs r)rz"Expression.make_VariableExpressions!(+++r+)FNrFT)&r,r-r.r rfrrrerdrrrrrrrr=r7r9rrErBrrrmrrrr rrrHrr"r$r#rrrNr+r)rrs FFKMMM"-+">">">999[9  222''' *** ))) *** *** !!!$$$$$   $6666.$$$$,t$$$$    $0$$$" F F F555             MMM ,,,,,r+rceZdZdZdZdZedZedfdZ dZ dZ d Z d Z d Zd ZejZd ZdZedZedZdZdS)ra` 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{rr r r s r)rzApplicationExpression.__init__s^ (J//UU1JX1UUUU(J//UU1JX1UUUU    r+c |j}|j}t|tr2|j|j|S|||Sr) r rr r{rrrrrr s r)rzApplicationExpression.simplifysv=))++=))++ h 0 1 1 6=(():HEENNPP P>>(H55 5r+cpt|jjtr|jjjSt Sr)r{r rrgrrmrs r)rzApplicationExpression.types, 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\rrr rrmr rgrrrr)rrrrs r)rzApplicationExpression._set_types*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+rir) r{ris_atomuncurryr r rmrlrrr)rrr argsfounduniquerpus ` r)rzApplicationExpression.findtype s(H--PP/E/PPPP <<>> #!\\^^NHdd}HM?DEEEEH:3DEEE % %AH}}%#""99Q<<"!E"MM!$$$ v;;!  <<? "Or+ct|jtrt}n|j}||jzSz:see: Expression.constants())r{r r rr$r )rfunction_constantss r)r$zApplicationExpression.constants'sQ dm%? @ @ ;!$  !%!8!8!:!: !DM$;$;$=$===r+ct|jtr|jjh}n|j}||jzSz:see: Expression.predicates())r{r rrr#r )rfunction_predss r)r#z ApplicationExpression.predicates/sR dm%7 8 8 8"m45NN!]5577N 8 8 : :::r+cT|||j||jgSz:see: Expression.visit())r r rs r)r zApplicationExpression.visit7s/z88DM22HHT]4K4KLMMMr+clt|to|j|jko|j|jkSr)r{rr r r5s r)r7zApplicationExpression.__eq__;s7 u3 4 4 0 / 0 / r+c||k SrrNr5s r)r9zApplicationExpression.__ne__Br: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__..Ks&::ctcz::::::r+r_FT)r<r=joinr r r{rrrr BooleanExpressionr r8r9)rr r>arg_str function_strparenthesize_functions r)rHzApplicationExpression.__str__Gs <<>> +!\\^^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)r r r{rinsert)rr r>s r)r=zApplicationExpression.uncurryash = #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. rr=rs r)predzApplicationExpression.predos||~~a  r+c6|dS)z+ Return uncurried arg-list rirXrs r)r>zApplicationExpression.argsxs ||~~a  r+c6t|jtS)zk Is this expression an atom (as opposed to a lambda expression applied to a term)? )r{rYr rs r)r<zApplicationExpression.is_atoms $)%?@@@r+)r,r-r.r rrrrrmrrr$r#r r7r9rrErHr=rYr>r<rNr+r)rrsD8!!!666X $,t26>>>;;;NNN   !!!"HCCC4    !!X!!!X! AAAAAr+rcdeZdZdZdZdZddZedfdZd Z d Z d Z d Z d Z ejZdZdS)r zDThis 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] }||_ dSr7N) r{r\rrrrrrorrrrr 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|jStSr9r)r{rrrrmrs r)rz#AbstractVariableExpression.findtypes@(H--PP/E/PPPP =H $ $9 Or+ctSrFrrs r)r#z%AbstractVariableExpression.predicates uu r+cLt|to|j|jkS)zTAllow equality between instances of ``AbstractVariableExpression`` subtypes.)r{r rr5s r)r7z!AbstractVariableExpression.__eq__s( u8 9 9 0 / r+c||k SrrNr5s r)r9z!AbstractVariableExpression.__ne__r:r+cZt|tst|j|jkSr)r{r r<rr5s r)r=z!AbstractVariableExpression.__lt__s)%!;<< O}u~--r+cd|jzSr^rrs r)rHz"AbstractVariableExpression.__str__sdm##r+r1)r,r-r.r rrrrmrrr#r7r9r=rrErHrNr+r)r r sNN!!!    $,t$$$$"   !!!... "H$$$$$r+r cHeZdZdZedfdZdZeeeZdZ dZ dS)r zThis 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 |dSrb) r{r\rrrlrrrrrrs r)rz&IndividualVariableExpression._set_typesx*d+++++  #D))I!!+.. F&tZEE E$-$%,,T22222r+ctSr)rrs r) _get_typez&IndividualVariableExpression._get_typesr+c|jhSz:see: Expression.free()rrs r)r"z!IndividualVariableExpression.free  r+ctSrCrhrs r)r$z&IndividualVariableExpression.constantsrir+) r,r-r.r rmrrqrrr"r$rNr+r)r r s{CC$,t 3 3 3 3 8Iy ) )Dr+r c"eZdZdZeZdZdZdS)rzwThis class represents variables that take the form of a single uppercase character followed by zero or more digits.c|jhSrsrrs r)r"zFunctionVariableExpression.freertr+ctSrCrhrs r)r$z$FunctionVariableExpression.constantsrir+N)r,r-r.r rmrr"r$rNr+r)rrsC22 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)rrs66 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] }||_ dSrb) r{r\rrrmrrrorrrrrcs r)rzConstantExpression._set_type s*d+++++  #D))I  ! !$JJ#JyK'''// :: t}12 ? ?E++J77J ?8>>> ? $-$%,,T222t}12 $ $E#EJJ $ $r+ctSrsrhrs r)r"zConstantExpression.free%rir+c|jhSrCrrs r)r$zConstantExpression.constants)rtr+) r,r-r.r rrrmrr"r$rNr+r)rrs\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{rrNrr rOrrPrrrs r)rr.s h ) )LL+AH+LLLL,+H555 HM " ",)(333 X] # #,&x000!(+++r+cXeZdZdZdZddZdZdZdZd Z d Z d Z d Z e jZd 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__Bs^ (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)r`rrz&%s is not a AbstractVariableExpressionT)rR) r{rrrr rrrr"rrVrs r)rz VariableBinderExpression.replaceLsO(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{rrrrrr)rnewvars r)rz&VariableBinderExpression.alpha_convertjsc &(++LL-Cf-LLLL~~ DI%%dm5G5O5OQUVV   r+cF|j|jhz Srs)rr"rrs r)r"zVariableBinderExpression.freetsy~~4=/11r+ct|ts Jd|z||jkrtS|j|Srf)r{rrrmrrrs r)rz!VariableBinderExpression.findtypexsN(H--PP/E/PPPP t} $ $O9%%h// /r+c6|||jgSrIrrs 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{rrrrr)rr6varexs r)r7zVariableBinderExpression.__eq__s dEO , ,  5$.0Q0Q }..yEJ..+4=99yEJ$6$6u~u$M$MMM5r+c||k SrrNr5s r)r9zVariableBinderExpression.__ne__r:r+Nr1)r,r-r.r rrrr"rr rr7r9rrErNr+r)rr>sOO<   222000111>>>   !!!"HHHr+rc6eZdZedZedfdZdZdS)rcpt|j|j|jjSr)rgrrrrrs r)rzLambdaExpression.types(49--dm<.&33Atax333333r+r_)rrrrr r/rPr7rrrs r)rHzLambdaExpression.__str__s]O yn..   T] + + +9Dn.. Mhh3333333 4j Tk  r+r,r-r.rrrmrrHrNr+r)rrsZ NNXN$,t < < < <      r+rc6eZdZedZedfdZdZdS)QuantifiedExpressionctSrrrs r)rzQuantifiedExpression.typer+Nct|tsJ|tt}|t st ||t |jt |dSrb r{r\rrrlrrrrrs 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 dSrNrNrs r)rOz/QuantifiedExpression.__str__..rr+r_)rrrr getQuantifierrPr 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.getQuantifiers {r+NrrNr+r)rrs#r+rcheZdZdZedZedfdZdZdZ dZ dZ d Z e jZd ZdS) rcXt|ts Jd|z||_dSr)r{rr)rrs r)rzNegatedExpression.__init__s1$ ++MM-F-MMMM r+ctSrrrs r)rzNegatedExpression.typerr+Nct|tsJ|tt}|t st ||t |jt |dSrbrrs r)rzNegatedExpression._set_typerr+czt|ts Jd|z|j|S)Nr)r{rrrrs r)rzNegatedExpression.findtypes<(H--PP/E/PPPPy!!(+++r+c6|||jgSrIrrs r)r zNegatedExpression.visitrr+c|jS)z:see: Expression.negate()rrs r)rzNegatedExpression.negates yr+cLt|to|j|jkSr)r{rrr5s r)r7zNegatedExpression.__eq__s!%!233O UZ8OOr+c||k SrrNr5s r)r9zNegatedExpression.__ne__ r:r+c0tjd|jzzSr^)r r;rrs r)rHzNegatedExpression.__str__szD49,,,r+)r,r-r.rrrrmrrr rr7r9rrErHrNr+r)rrsX$,t 3 3 3 3,,,111PPP!!!"H-----r+rc\eZdZdZedZdZdZdZdZ e j Z dZ dZ d S) BinaryExpressionct|ts Jd|zt|ts Jd|z||_||_dSr)r{rrrrs r)rzBinaryExpression.__init__s\%,,OO.G%.OOOO&*--QQ/H6/QQQQ  r+ctSrrrs r)rzBinaryExpression.typerr+ct|ts Jd|z|j|}|j|}||ks |t kr|S|t kr|St Srf)r{rrrrrm)rrrpr)s r)rzBinaryExpression.findtypesy(H--PP/E/PPPP J   ) ) K  * * 66Q(]]H (]]HOr+cT|||j||jgSrI)rrrs r)r zBinaryExpression.visit*s/z88DJ//$+1F1FGHHHr+ct||jst||jo|j|jko|j|jkSr)r{rrrr5s r)r7zBinaryExpression.__eq__.sI eo . . S*UDN2S2S , ek) , u|+ r+c||k SrrNr5s r)r9zBinaryExpression.__ne__5r:r+c||j}||j}tj|zdz|zdz|ztjzS)Nr) _str_subexrrr r8getOpr9rs r)rHzBinaryExpression.__str__:sX ++--{U"S(4::<<7#=FUUr+c d|zSr^rN)rsubexs r)rzBinaryExpression._str_subex?s e|r+N)r,r-r.rrrrr r7r9rrErHrrNr+r)rrs X   III   !!!"HVVV r+rceZdZedfdZdS)rQNc@t|tsJ|tt}|t st ||t |jt ||j t |dSrb) r{r\rrrlrrrrrrs r)rzBooleanExpression._set_typeDs*d+++++  #D))I!!*-- E&tZDD D Z333 j)44444r+)r,r-r.rmrrNr+r)rQrQCs-#+t 5 5 5 5 5 5r+rQceZdZdZdZdZdS)rz"This class represents conjunctionsctjSr)r r=rs r)rzAndExpression.getOpTrr+cNd|z}t|tr |ddS|SNr_rir)r{rrrr)s r)rzAndExpression._str_subexWs/ 5L e] + + QrT7Nr+Nr,r-r.r rrrNr+r)rrQs8,,r+rceZdZdZdZdZdS)rz"This class represents disjunctionsctjSr)r r?rs r)rzOrExpression.getOpa yr+cNd|z}t|tr |ddS|Sr)r{rrs r)rzOrExpression._str_subexds/ 5L e\ * * QrT7Nr+NrrNr+r)rr^s8,,r+rceZdZdZdZdS)rz"This class represents implicationsctjSr)r rArs r)rzImpExpression.getOpnrr+Nr,r-r.r rrNr+r)rrks),,r+rceZdZdZdZdS)rz$This class represents biconditionalsctjSr)r rCrs r)rzIffExpression.getOpurr+NrrNr+r)rrrs)..r+rc$eZdZdZedfdZdZdS)rz:This class represents equality expressions like "(x = y)".Nc@t|tsJ|tt}|t st ||t |jt||j t|dSrb) r{r\rrrlrrrrrrrs r)rzEqualityExpression._set_type|s*d+++++  #D))I!!*-- E&tZDD D [)444 k955555r+ctjSr)r rErs r)rzEqualityExpression.getOprr+)r,r-r.r rmrrrNr+r)rrysBDD#+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 r2z ^[a-df-z]\d*$Nr{r3r$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 r2z ^[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 r2z^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)demors  !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_errorsrs 4555.!!!%&&&*%&'(+$)*+/"""""r+c t|dS#t$r)}t|jjd|Yd}~dSd}~wwxYw)Nr)rrdrrWrr,)r)rs r)rrss.a     %... %,,,,---------.s AA  Ac\t|d|jdS)Nz : )rWr3r)exs r) printtyper s. RVVXX # #"' # #$$$$$r+__main__)NNr)Kr rr$ collectionsr functoolsrrnltk.internalsr nltk.utilrrrQr r[r_rdrfr/rrVrZr\rgrtrzrrrrrrzrmrbrrrrrrrrrr r rrrrrrrrrrrrrQrrrrrrrrrNrOrPrrrrr,rNr+r)rs  ######,,,,,,,,""""""  799*I*I*I*I*I*I*I*IZ"""""""""i@i@i@i@i@i@i@i@X<,,,,,,,,@    8            2B2B2B2B2B$2B2B2Bj&Y iB^   jll Y[[ 799   >I             m        =        $$$$$$$$,H,H,H,H,H,$H,H,H,VGAGAGAGAGAJGAGAGATH$H$H$H$H$H$H$H$V#=<     !;   :$$$$$3$$$N , , , Z#Z#Z#Z#Z#zZ#Z#Z#z     /   <     3   >+ ( ) )-)-)-)-)- )-)-)-X-----z---` 5 5 5 5 5( 5 5 5     %        $   %%),******** > > > > >9 > > >      "<    8 8 8 5 5 5 1 1 1B###"...%%% zDFFFFFr+