OfN SrSSKrSSKrSSKJr SSKJrJr SSKJ r SSK J r Sr \ "5r "SS 5rS rS rS r"S S5rSgSjr\"SS55rSgSjrShSjr"SS5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"S S!\\5r\"5r\"5r\"5r \"5r!S"r""S#S$\#5r$"S%S&\$5r%"S'S(\$5r&"S)S*\$5r'ShS+jr("S,S-5r)"S.S/\)5r*"S0S1\*5r+\"S2S3\*55r,"S4S5\,5r-"S6S7\,5r."S8S9\-5r/"S:S;\,5r0S<r1"S=S>\*5r2"S?S@\25r3"SASB\25r4"SCSD\45r5"SESF\45r6"SGSH\45r7"SISJ\*5r8"SKSL\*5r9"SMSN\95r:"SOSP\:5r;"SQSR\:5r<"SSST\:5r="SUSV\:5r>"SWSX\95r?"SYSZ\#5r@"S[S\\@5rA"S]S^\@5rBS_rCS`rDSarESbrFScrGSdrHSerI\JSf:Xa\F"5 gg)izV A version of first order predicate logic, built on top of the typed lambda calculus. N) defaultdict)reducetotal_ordering)Counter)TrieAPPc t\rSrSrSrS/rSr/SQrSrSS/r Sr S/r Sr S r S rS rS r/S QrSr/SQrSrSS/rSr/SQrSr/SQrSrSS/rSrS/r\\-\-\-r\\ -\ -r\ \ \\/r \\-\-\-\-\ -\-r!\!VVVs/sH#n[DRF"SU5(dM!UPM% snnnr$Sr%gs snnnf)Tokens\exists)somer existallforalliota.(),-)notr!&)andr^|or->)impliesrz=><->)iffr!z<=>=z==z!=z^[-\\.(),!&^|>=<]*$N)&__name__ __module__ __qualname____firstlineno__LAMBDA LAMBDA_LISTEXISTS EXISTS_LISTALLALL_LISTIOTA IOTA_LISTDOTOPENCLOSECOMMANOTNOT_LISTANDAND_LISTOROR_LISTIMPIMP_LISTIFFIFF_LISTEQEQ_LISTNEQNEQ_LISTBINOPSQUANTSPUNCTTOKENSrematchSYMBOLS__static_attributes__).0xrGs0000/usr/lib/python3/dist-packages/nltk/sem/logic.pyr r s 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( RF!H&QBHH-CQ$Gq&HGHs  B3%B3r c/SQn[U[R[R[R[R [R /5Hn[SU-5 M g)z Boolean operators )negation conjunction disjunction implication equivalence%-15s %sN)zipr r5r7r9r;r=printnamespairs rM boolean_opsrZHsH UEEFJJ FIIvzz6::VW kD !XcSS/n[U[R[R/5Hn[ SU-5 M g)z Equality predicates equality inequalityrTN)rUr r?rArVrWs rMequality_predsr_Qs9 &EEFIIvzz23 kD !4r[c/SQn[U[R[R[R[R /5Hn[ SU-5 M g)z Binding operators ) existential universallambdarTN)rUr r+r-r)r/rVrWs rM binding_opsrdZsA 3EEFMM6::v}}fkkRS kD !Tr[c\rSrSrSrS&SjrS'SjrSrSrSr S r S'S jr S r S r S rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr S r!S!r"S"r#S#r$S$r%S%r&g)( LogicParsercz$A lambda calculus expression parser.cZ[U[5(deSUl/UlXl/Ul[ [RVs/sHo"S4PM sn[RVs/sHo"S4PM sn-[S4/-[R[R-Vs/sHo"S4PM sn-[RVs/sHo"S4PM sn-[RVs/sHo"S4PM sn-[RVs/sHo"S4PM sn-[R Vs/sHo"S 4PM sn-[R"Vs/sHo"S 4PM sn-S /-5Ul[/Ulg s snfs snfs snfs snfs snfs snfs snfs snf) za :param type_check: should type checking be performed to their types? :type type_check: bool r )N N) isinstancebool _currentIndex_buffer type_check quote_charsdictr r*r6rr@rBrDr8r:r<r>operator_precedenceright_associated_operations)selfrwrLs rM__init__LogicParser.__init__fs *d++++ $ /#'#// 0/V/ 0%/!1v/ 0Qxj  &~~?@?!1v?@ A &}}-}!1v}-  . &/!1v/  0 &~~.~!1v~.  / &/!1v/ 0 &/!1v/ 0l  $  -05( 1/@-/.//s0 F, F * F F 0 F  F 6 F#  F( Nc UR5nSUlURU5uUlnUR S5nUR S5(a([ URS-URS55eUR(aURU5 U$![a6nSRXQSX5RS- -5n[SU5UeSnAff=f)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 {} {} {}^ ) rstripruprocessrvprocess_next_expressioninRangeUnexpectedTokenExceptiontokenLogicalExpressionExceptionformatindexrw typecheck)r|data signaturemappingresultemsgs rMparseLogicParser.parses{{} $ T 2 g ?11$7F||A.t/A/AA/EtzzRS}UU ??   Y ' * ?&&qgggk6J0JKC,T37Q > ?sAB&& C&01C!!C&c/n0n[UR55nSnSnUnU[U5:Ga3UnURXa5upU (aU(dUnXY- nM;Un Xn Sn X;a<X- n Xn [U5U- [U 5:aX[U 5-n OOX;aM<[RU ;aTU(a Xs[U5'UR U5 SnXc[U5'UR U 5 U[U 5- nOEXS;a(U(a Xs[U5'UR U5 SnOU(dUnXQU- nUS- nU[U5:aGM3U(aXs[U5'UR U5 [U5U[U5'[U5S-U[U5S-'X#4$)zSplit the data into tokensrz ri)rget_all_symbolslenprocess_quoted_tokenLEAFappend) r|routr tokenTrierdata_idxtoken_start_idx cur_data_idx quoted_tokenstcsymbols rMrLogicParser.processs--/0 "T"#L%)%>%>x%N "L&2O%BAF' Ut9x'#f+5F 34A 'yyB(7CH%JJu%E$,C! 6"CK'>W,,;C) 5) " *2(^+EA MT"N  /CH  JJu IC #D A C1 |r[cSnX!nUnURHupgpXF:XdM U (aX4- nUS- nX%U:wauX%U:Xa9U (aX2U- nUS- n[U5U:Xa[SSU-5eX2U- nOX2U- nUS- n[U5U:Xa[SSU-5eX%U:waMuU (aX2U- nUS- nU(d [SS5e X54$ X54$)Nrriz:End of input reached. Escape character [%s] found at end.z%End of input reached. Expected: [%s]zEmpty quoted token found)rxrr) r|rrrristartendescape incl_quotess rMr LogicParser.process_quoted_tokens% N /3/?/? +EzJEQgnw&(&!!W,EQt9>"< $!FHN!O# a(a(FA4yA~8 "Ls"R!gn&!W$EQ4T;UVVx=0@<xr[c"[R$)z#This method exists to be overridden)r rIr|s rMrLogicParser.get_all_symbolss ~~r[cLURU-[UR5:$)z6Return TRUE if the given location is within the buffer)rurrv)r|locations rMrLogicParser.inRanges!!!H,s4<[ U[ 5(d.[ U[5(d[URSU-5eUR5 URX0R[55nURS5(aURS5[R:XaoUR5 URX0R[55nURS5(a%URS5[R:XaMoUR[R5 U$)NrzW'%s' is an illegal predicate name. Individual variables may not be used as predicates.)make_VariableExpressionrrr r2rsFunctionVariableExpressionConstantExpressionrrumake_ApplicationExpressionrrr4assertNextTokenr3r|rrrs rMrLogicParser.handle_variableLs*,,S1 <<??tzz!} ;e%?@@)JJ1&&"$'( JJL3333C8E,,q//djjmv||&C 7777<,,q//djjmv||&C   . r[cUR5n[UR U5[ 5(a[ URSU<SU<S35e[U5$![an[URS5UeSnAff=f)NzVariable expected.'z5' is an illegal variable name. Constants may not be r) rrrrsrrrruVariable)r| descriptionrrs rMget_next_token_variable#LogicParser.get_next_token_variablejs T**,C d22379K L L,"".1;@  }+ T-agg7KLRS S TsA B*BBcURS5(d[URS-SS9eURS5/nURS5(a9UR S5[ R :Xa-URS5(d[URS-SS9eURUR S55(dO"URURS55 MURS5(a3UR S5[ R :XaUR 5 URU5nU(a)URUR5U5nU(aM)U$)Nrrjz;Variable and Expression expected following lambda operator.r abstractedrir) rrrurrr r1rrrmake_LambdaExpressionpop)r|rrvarsrs rMrLogicParser.handle_lambdaws*||A-""Q&U ,,\:;<<?? 1 +DLLOO1&&*4J??4::a=11 KK44\B C <<??tzz!} : JJL,,S1..txxz5AEd r[cURU5nURS5(d[URS-SU-S9eUR S5/nURS5(a9UR S5[ R:Xa-URS5(d[URS-SS9eURUR S55(dO"URUR S55 MURS5(a3UR S5[ R:XaUR 5 URU5nU(a)URX4R5U5nU(aM)U$)Nrrjz;Variable and Expression expected following quantifier '%s'.r quantifiedrir) get_QuantifiedExpression_factoryrrrurrr r1rrrmake_QuanifiedExpressionr)r|rrfactoryrrs rMrLogicParser.handle_quantsB77<||A-""Q&U  ,,\:;<<?? 1 +DLLOO1&&*4J??4::a=11 KK44\B C <<??tzz!} : JJL,,S111'88:uMEd r[cU[R;a[$U[R;a[$U[R ;a[ $URU[R5 g)zTThis method serves as a hook for other logic parsers that have different quantifiersN) r r,ExistsExpressionr. AllExpressionr0IotaExpression assertTokenrDrs rMr,LogicParser.get_QuantifiedExpression_factorysR &$$ $# # FOO # F$$ $! !   S&-- 0r[cU"X#5$rr$)r|rvariableterms rMr$LogicParser.make_QuanifiedExpressions x&&r[cfURS5nUR[R5 U$r)rrr r3rs rMrLogicParser.handle_opens),,T2 V\\* r[ctURS5(aURS5nU[R[R-;akUR X25(aUUR5 UR XRU55nU[R;aURU5nU$)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 r@rB has_prioritymake_EqualityExpressionrr)r|rrrs rMr&LogicParser.attempt_EqualityExpressions <<??**Q-Cfnnv664;L;L<< !99 < IffExpressionrs rMr )LogicParser.get_BooleanExpression_factorysO &// ! FNN "  FOO # FOO # r[cU"X#5$rr$)r|rrrs rMr "LogicParser.make_BooleanExpressions u%%r[cUR[U5(GaURS5(GaURS5[R :XGam[ U[5(d[[ U[5(dF[ U[5(d1[ U[5(d[URSU-S-5eUR5 URXR[55nURS5(aURS5[R:XaoUR5 URX0R[55nURS5(a%URS5[R:XaMoUR![R"5 U$U$)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 r2rsLambdaExpressionApplicationExpressionrrrrurrr4rr3)r|rrrs rMr)LogicParser.attempt_ApplicationExpressionsJ   S' * *||A4::a=FKK#?":/?@@&z3HII&z3MNN&z3EFF4**+j8.. 77 < )rr __class__r%)r|rs rM__repr__LogicParser.__repr__GsJ <<?? 4::a=0C"CT^^,,,t3c9C??r[)rvrurzrxr{rw)Fr)'r%r&r'r(__doc__r}rrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrr6rJr$r[rMrfrfcs.#1J64l"HA M(5$2$U-< 6< 1' "1  &!F920  RR@r[rfcvUbURU5nUc [5n/n[UR55HTupEUR 5nUR S5(dUS:XaM3UR URU55 MV U$![an[SUSU35UeSnAff=f)av 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 r3) decoderf enumerate splitlinesstrip startswithrrr ValueError)s logic_parserencoding statementslinenumliners rM read_logicrGOs HHX "} J"1<<>2 zz| ??3  42:  O   l006 7 3 * O4WIRvFGQ N Os1 B B8!B33B8cD\rSrSrSrSrSrSrSrSr Sr S r S r g ) rimcN[U[5(d SU-5eXlg)z' :param name: the name of the variable %s is not a stringN)rsstrr"r!s rMr}Variable.__init__os'$$$A&:T&AA$ r[cb[U[5=(a URUR:H$r)rsrr"r|others rM__eq__Variable.__eq__vs!%*FtyyEJJ/FFr[c X:X+$rr$rNs rM__ne__Variable.__ne__y   r[cj[U[5(d[eURUR:$r)rsr TypeErrorr"rNs rM__lt__Variable.__lt__|s'%**Oyy5::%%r[c$URX5$r)getr|bindingss rMsubstitute_bindingsVariable.substitute_bindingss||D''r[c,[UR5$r)hashr"rs rM__hash__Variable.__hash__sDIIr[cUR$rr"rs rM__str__Variable.__str__s yyr[c SUR-$)NzVariable('%s')rers rMr6Variable.__repr__s$))++r[reN) r%r&r'r(r}rPrSrXr^rbrfr6rJr$r[rMrrms+G!& (,r[rctUb^[UR5(aSnOC[UR5(aSnO&[UR5(aSnO S5eSn[ U[ R 535nUb0X1;a+[ U[ R 535nUbX1;aM+U$)z 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 zFe0z!Cannot generate a unique constant) is_indvarr" is_funcvar is_eventvarr_counterr[)patternignoreprefixvs rMunique_variablervs W\\ " "F  % %F  & &F == =5F8HLLN+,-A   x /0 1   Hr[c[[S[R5-55nU(a#[ U5HnU"[U55nM U$)zL Return a skolem function over the variables in univ_scope param univ_scope zF%s)r rrqr[r,) univ_scopeskolemrus rMskolem_functionrzsE  )? @ AFj!A.q12F" Mr[c0\rSrSrSrSr\S5rSrg)Typeic SU-$N%sr$rs rMr6 Type.__repr__s d{r[c[SU-5$r~)rars rMrb Type.__hash__sD4K  r[c[U5$r) read_type)clsrAs rM fromstringType.fromstrings |r[r$N) r%r&r'r(r6rb classmethodrrJr$r[rMr|r|s !r[r|cV\rSrSrSrSrSr\RrSr Sr Sr Sr S r g ) ComplexTypeic[U[5(d SU-5e[U[5(d SU-5eXlX lg)Nz%s is not a Type)rsr|rrrs rMr}ComplexType.__init__sH%&&B(:U(BB&&$''D);f)DD'  r[c[U[5=(a9 URUR:H=(a URUR:H$r)rsrrrrNs rMrPComplexType.__eq__s; uk * , ekk) , u||+ r[c X:X+$rr$rNs rMrSComplexType.__ne__rUr[c[U[5(aQURRUR5=(a% URRUR5$U[ :H$r)rsrrmatchesrANY_TYPErNs rMrComplexType.matchessK e[ ) )::%%ekk2Xt{{7J7J5<<7X X8# #r[c&U[:XaU$[U[5(adURR UR5nUR R UR 5nU(aU(a [X#5$gU[:XaU$gr)rrsrrresolver)r|rOfrAs rMrComplexType.resolveso H K { + + ""5;;/A ##ELL1AQ"1(( X Lr[cbU[:Xa S[-$SURSURS3$)Nrr2rr4)rrrrs rMrfComplexType.__str__s1 8 (? "tzzl!DKK=2 2r[cU[:Xa[R5$SURR5SURR5S3$)Nrz -> r)rrKrrrs rMrKComplexType.strsC 8 <<> !tzz~~'(T[[__->,?qA Ar[rrN)r%r&r'r(r}rPrSr|rbrrrfrKrJr$r[rMrrs1  !}}H$ 3 Br[rcD\rSrSrSrSr\RrSrSr Sr g) BasicTypeicF[U[5=(a SU-SU-:H$r~)rsrrNs rMrPBasicType.__eq__s!%+O$,0OOr[c X:X+$rr$rNs rMrSBasicType.__ne__rUr[c*U[:H=(d X:H$r)rrNs rMrBasicType.matchess 1DM1r[c4URU5(aU$gr)rrNs rMrBasicType.resolves <<  Kr[r$N) r%r&r'r(rPrSr|rbrrrJr$r[rMrrs"P!}}H2r[rc \rSrSrSrSrSrg) EntityTypei cg)Nrr$rs rMrfEntityType.__str__ r[cg)NINDr$rs rMrKEntityType.strr[r$Nr%r&r'r(rfrKrJr$r[rMrr s r[rc \rSrSrSrSrSrg)TruthValueTypeicg)Ntr$rs rMrfTruthValueType.__str__rr[cg)NBOOLr$rs rMrKTruthValueType.strsr[r$Nrr$r[rMrrs r[rc \rSrSrSrSrSrg) EventTypeicg)Nrur$rs rMrfEventType.__str__rr[cg)NEVENTr$rs rMrK EventType.strsr[r$Nrr$r[rMrrs r[rcv\rSrSrSr\S5r\S5rSrSr \ Rr Sr Sr S rS rS rg ) AnyTypei"cgrr$rs rMr}AnyType.__init__#s r[cU$rr$rs rMr AnyType.first& r[cU$rr$rs rMrAnyType.second*rr[cR[U[5=(d URU5$r)rsrrPrNs rMrPAnyType.__eq__.s%)?U\\$-??r[c X:X+$rr$rNs rMrSAnyType.__ne__1rUr[cg)NTr$rNs rMrAnyType.matches6sr[cU$rr$rNs rMrAnyType.resolve9s r[cg)N?r$rs rMrfAnyType.__str__<rr[cg)NANYr$rs rMrK AnyType.str?rr[r$N)r%r&r'r(r}propertyrrrPrSr|rbrrrfrKrJr$r[rMrr"sY @!}}Hr[rc[U[5(deURSS5nUSS:XayUSS:XdeSn[U5H7up#US:XaUS- nMUS:XaUS-nUS:deM'US:XdM/US:XdM7 O [ [ USW5[ XS-S55$USS [ -:Xa[ $USS [-:Xa[$USS [-:Xa[$[SS US-5e) Nrrrr2r4rirrzUnexpected character: '%s'.) rsrKreplacer<rr ENTITY_TYPE TRUTH_TYPErr) type_string paren_countrchars rMrrIs* k3 ' '' '%%c2.K1~2#%%%  -GAs{q q "Q&!#. k!A& ';1ur3J)K   Q4+- - Q4*, , Q4(? *( /+a.@  r[c(^\rSrSrU4SjrSrU=r$) TypeExceptionihc$>[TU]U5 grsuperr})r|rr5s rMr}TypeException.__init__is r[r$r%r&r'r(r}rJ __classcell__r5s@rMrrhs r[rc,^\rSrSrSU4SjjrSrU=r$)"InconsistentTypeHierarchyExceptionimcT>U(a SU<SU<S3nOSU-n[TU]U5 g)NzThe variable 'z8' was found in multiple places with different types in ''.zDThe variable '%s' was found in multiple places with different types.r)r|rrrr5s rMr}+InconsistentTypeHierarchyException.__init__ns8 &.z;  %'  r[r$rrrs@rMrrms   r[rc(^\rSrSrU4SjrSrU=r$)TypeResolutionExceptioni|c R>[TU]SU<SUR<SU<S35 g)Nz The type of 'z', 'z!', cannot be resolved with type 'r)rr}type)r|r other_typer5s rMr} TypeResolutionException.__init__}s  :??J 8 r[r$rrs@rMrr|   r[rc(^\rSrSrU4SjrSrU=r$)IllegalTypeExceptionic n>[TU]SURR<SU<SU<SU<S3 5 g)NzCannot set type of z 'z' to 'z'; must match type 'r)rr}r5r%)r|rr allowed_typer5s rMr}IllegalTypeException.__init__s+ ##,,j*l T r[r$rrs@rMrrrr[rctUHnURU5nM USSHnURU5 M U$)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 rMrrsE" ((3 ""#2& Y'' r[c$\rSrSrSrSrSrSrg)SubstituteBindingsIizH An interface for classes that can perform substitutions for variables. c[5e)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 rMr^'SubstituteBindingsI.substitute_bindings "##r[c[5e)z2 :return: A list of all variables in this object. rrs rM variablesSubstituteBindingsI.variabless "##r[r$N)r%r&r'r(r8r^rrJr$r[rMrrs $$r[rc\rSrSrSr\"5r\"SS9r\S$Sj5r Sr Sr S r S r S rS rS rSrSrSrS%SjrSrSrS%SjrSr\S4SjrS&SjrS%SjrSrSrSrSr Sr!Sr"Sr#S r$S!r%S"r&S#r'g)' Expressioniz >T))r[c^[U[5(d[SU-5e[X5$r)rsrrWrrNs rM__or__Expression.__or__s+%,,5=> >D((r[c^[U[5(d[SU-5e[X5$r)rsrrWrrNs rM__gt__Expression.__gt__r r[c^[U[5(d[SU-5e[X5$r)rsrrWrrNs rMrXExpression.__lt__r r[c[$r)NotImplementedrNs rMrPExpression.__eq__sr[c X:X+$rr$rNs rMrSExpression.__ne__rUr[c[U[5(d SU-5eUc SSKJn U"5n[ UR 5UR 55nUR U5$)a  Check for logical equivalence. Pass the expression (self <-> other) to the theorem prover. If the prover says it is valid, then the self and other are equal. :param other: an ``Expression`` to check equality against :param prover: a ``nltk.inference.api.Prover`` rr)Prover9)rsrnltk.inferencer/rsimplifyprove)r|rOproverr/biconds rMequivExpression.equivsY%,,O.G%.OO, > .YFt}}0@A||F##r[c*[[U55$r)rareprrs rMrbExpression.__hash__sDJr[cDUnUR5H{nX1;dM Xn[U[5(aURU5nO$[U[5(d[ SU<35eUR U5nURX45nM} UR5$)Nz>Can not substitute a non-expression value into an expression: ) rrsrrrr@r^rr1)r|r]exprvarvals rMr^Expression.substitute_bindingss>>#Cmc8,,66s;C#C44$:=@ --h7||C-$}}r[cZ[[5nU(a`UHZnXn[[U55n[ U[ 5(aXElO[U5UlX#RU5 M\ URUS9 UVs0sHo3X#SR _M sn$s snf)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 )rr) rr,r rrsr|rrr _set_type)r|rsigkeyr=varExs rMrExpression.typechecks$  n*8C=9c4((!$J!*3EJ&! %145#SXa[%%%555s B(c[5e)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 rr|rs rMfindtypeExpression.findtype)rr[c[5e)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)) rr|rrs rMr@Expression._set_type2s "##r[c^^^^[T[5(d ST-5e[T[5(d ST-5eURUUUU4SjUR5$)aE 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 Variablerc,>URTTTT5$r)r)r alpha_convertr replace_boundrs rM$Expression.replace..Jsaii*m]Sr[)rsrrvisit_structuredr5r|rrrPrOs ````rMrExpression.replace<sd(H--P/E/PP-*j11 % 2 1$$ S NN  r[ct^U4SjmUn[[T"U5SS95Hup4[U[5(a!UR [ SUS--55nO8[U[ 5(a!UR [ SUS--55nOUnURURUS5nM U$)z&Rename auto-generated unique variablesc>[U[5(aU1$[U[5(a [5$UR TS5$)NcH[[RU[55$rroperatoror_setpartss rMrQ>Expression.normalize..get_indiv_vars..Xs&uce2Tr[)rsIndividualVariableExpressionAbstractVariableExpressionr\visit)rget_indiv_varss rMrc,Expression.normalize..get_indiv_varsQsD!9::s A9::u ww"$Tr[cUR$rrrs rMrQ&Expression.normalize..\sr[)rBze0%srizz%sT) r<sortedrsEventVariableExpressionr5rr`rr)r|newvarsrrrnewVarrcs @rM normalizeExpression.normalizeNs f^D%9?STUDA!455XfA.>%?@A;<<Xeq1uo%>?^^AJJ=FV r[c[5e)a 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`` rr|r combinators rMrbExpression.visitfs "##r[c0^URUU4Sj5$)a 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>T"U6$rr$)r^rqs rMrQ-Expression.visit_structured..s *e2Dr[rbrps `rMrSExpression.visit_structuredwszz($DEEr[c<SURRSUS3$)Nr2rr4)r5r%rs rMr6Expression.__repr__s"4>>**+1TF!44r[c"UR5$r)rKrs rMrfExpression.__str__sxxzr[cUR5UR5UR5-Vs1sH-n[R"SUR 5(dM+UiM/ sn-$s snf)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 z^[?@])free predicates constantsrGrHr")r|ps rMrExpression.variabless[yy{(4>>+;; ;!rxxQRQWQW?XA;    s *A,!A,c*URSS5$)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"UR5$r)r}rgs rMrQ!Expression.free..s affhr[cH[[RU[55$rrYr]s rMrQrsfX\\5#%.Pr[rvrs rMr}Expression.frees zz  P  r[c*URSS5$)z] Return a set of individual constants (non-predicates). :return: set of ``Variable`` objects c"UR5$r)rrgs rMrQ&Expression.constants..s akkmr[cH[[RU[55$rrYr]s rMrQrs6(,,su3Ur[rvrs rMrExpression.constantss zz #%U  r[c*URSS5$)z] Return a set of predicates (constants, not variables). :return: set of ``Variable`` objects c"UR5$r)r~rgs rMrQ'Expression.predicates..s allnr[cH[[RU[55$rrYr]s rMrQrsF8<<PSPU4Vr[rvrs rMr~Expression.predicatess zz $&V  r[c<URSUR5$)z4 :return: beta-converted version of this expression c"UR5$r)r1rgs rMrQ%Expression.simplify..s qzz|r[)rSr5rs rMr1Expression.simplifys$$%;T^^LLr[c[U5$r)r rFs rMr"Expression.make_VariableExpressions !(++r[r$)FNrFT)(r%r&r'r(r8rfr r rrrrrrrr"r%rXrPrSr5rbr^rrGrr@rrmrbrSr6rfrr}rr~r1rrJr$r[rMrrsFMM"-">99  2' * ) * * !$$ $6.$$,t$ $0$" F5     M ,r[rc\rSrSrSrSrSr\S5r\ S4Sjr Sr S r S r S rS rS r\R$rSrSr\S5r\S5rSrSrg)ria  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)". c[U[5(d SU-5e[U[5(d SU-5eXlX lg)zp :param function: ``Expression``, for the function expression :param argument: ``Expression``, for the argument rN)rsrrrrs rMr}ApplicationExpression.__init__sJ (J//U1JX1UU/(J//U1JX1UU/  r[cURR5nURR5n[U[5(a4UR R URU5R5$URX5$r) rr1rrsrrrrr5rs rMr1ApplicationExpression.simplifysi==))+==))+ h 0 1 1==(():):HENNP P>>(5 5r[c[URR[5(a URRR$[ $r)rsrrrrrrs rMrApplicationExpression.types4 dmm((+ 6 6==%%,, ,Or[Nc&[U[5(deUc[[5nURR [ U5 URR [URRU5U5 g![an[SUR<SURR<SUR<SURR<SURRR<S3 5UeSnAff=f):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) rsr|rr,rr@rrrrrrr)r|rrrs rMr@ApplicationExpression._set_types*d++++  #D)I )4  MM # #DMM.. ;Y ' MMMM&&MMMM&&MM&&,,   s :B DA;D  Dc[U[5(d SU-5eUR5(aUR5up#OURnUR /nU/U-Vs/sHoDR U5PM nn/nUHKnU[:wdMU(a$UHnURU5(dM M6 M:URU5 MM [U5S:Xa[U5S$[$s snf):see Expression.findtype()rMrir) rsris_atomuncurryrrrGrrrrr,) r|rrargsargfounduniquerus rMrGApplicationExpression.findtype s(H--P/E/PP- <<>>!\\^NHd}}HMM?D4<:3DE3DCh'3DEAH}#99Q<<!$MM!$ v;! <? "OFs)C;c[UR[5(a [5nOURR 5nXR R 5-$z:see: Expression.constants())rsrrar\rr)r|function_constantss rMrApplicationExpression.constants'sE dmm%? @ @!$ !%!8!8!: !MM$;$;$===r[c[UR[5(aURR1nOURR 5nXR R 5-$z:see: Expression.predicates())rsrrrr~r)r|function_predss rMr~ ApplicationExpression.predicates/sN dmm%7 8 8"mm445N!]]557N 8 8 :::r[cVU"U"UR5U"UR5/5$z:see: Expression.visit())rrrps rMrbApplicationExpression.visit7s$8DMM2HT]]4KLMMr[c[U[5=(a9 URUR:H=(a URUR:H$r)rsrrrrNs rMrPApplicationExpression.__eq__;s< u3 4 0 / 0 / r[c X:X+$rr$rNs rMrSApplicationExpression.__ne__BrUr[cUR5(a+UR5upSRSU55nOURnSUR-nSU-nSn[ U[ 5(am[ UR[5(a,[ URR[5(dSnO9[ UR[5(dSnO[ U[5(aSnU(a$[RU-[R-nU[R-U-[R-$)Nrc3,# UH nSU-v M g7frNr$)rKrs rM 0ApplicationExpression.__str__..Ks:TctczTrFT)rrjoinrrrsrrrraBooleanExpressionr r2r3)r|rrarg_str function_strparenthesize_functions rMrfApplicationExpression.__str__Gs <<>>!\\^NHhh:T::G}}HT]]*Gh % h 0 1 1(--)>??!(--"8"8:TUU,0) /@AA(,% "7 8 8$( ! !;;5 DLfkk)G3fllBBr[cURnUR/n[U[5(a?UR SUR5 URn[U[5(aM?X4$)zP Uncurry this application expression return: A tuple (base-function, arg-list) r)rrrsrinsert)r|rrs rMrApplicationExpression.uncurryas` == #899 KK8,, -((H#899r[c(UR5S$)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. rrrs rMpredApplicationExpression.predos||~a  r[c(UR5S$)z Return uncurried arg-list rirrs rMrApplicationExpression.argsxs ||~a  r[c6[UR[5$)zS Is this expression an atom (as opposed to a lambda expression applied to a term)? )rsrrars rMrApplicationExpression.is_atoms $))%?@@r[)rr)r%r&r'r(r8r}r1rrrr@rGrr~rbrPrSrrbrfrrrrrJr$r[rMrrs8!6 $,t26>;N !""HC4  !!!! Ar[rcx\rSrSrSrSrSrSSjr\S4Sjr Sr S r S r S r S r\R rS rSrg)raizDThis class represents a variable to be used as a predicate or entitycN[U[5(d SU-5eXlg)z1 :param variable: ``Variable``, for the variable rMN)rsrrrFs rMr}#AbstractVariableExpression.__init__s'(H--P/E/PP- r[cU$rr$rs rMr1#AbstractVariableExpression.simplifys r[c[U[5(d SU-5e[U[5(d SU-5eURU:XaU$U$):see: Expression.replace()z%s is not an Variabler)rsrrrrTs rMr"AbstractVariableExpression.replaces[(H--Q/F/QQ-*j11 % 2 1 ==H $ Kr[Nc[U[5(deUc[[5nUnX RR H0nUR RU5nU(aM'[U5e X RR RU5 X RR H nX4lM grN) rsr|rr,rr"rrrrr|rr resolutionrCs rMr@$AbstractVariableExpression._set_types*d++++  #D)I }}112E++J7J:8>>3 --$$%,,T2}}112E#J3r[c[U[5(d SU-5eURU:Xa UR$[$rrM)rsrrrrrFs rMrG#AbstractVariableExpression.findtypes;(H--P/E/PP- ==H $99 Or[c[5$rr\rs rMr~%AbstractVariableExpression.predicates u r[cb[U[5=(a URUR:H$)zLAllow equality between instances of ``AbstractVariableExpression`` subtypes.)rsrarrNs rMrP!AbstractVariableExpression.__eq__s) u8 9 0 / r[c X:X+$rr$rNs rMrS!AbstractVariableExpression.__ne__rUr[cj[U[5(d[eURUR:$r)rsrarWrrNs rMrX!AbstractVariableExpression.__lt__s(%!;<<O}}u~~--r[c SUR-$r~rfrs rMrf"AbstractVariableExpression.__str__sdmm##r[rfr)r%r&r'r(r8r}r1rrr@rGr~rPrSrXrrbrfrJr$r[rMrarasKN! $,t$" !. ""H$r[racJ\rSrSrSr\S4SjrSr\"\\5r Sr Sr Sr g) r`izThis class represents variables that take the form of a single lowercase character (other than 'e') followed by zero or more digits.Nc[U[5(deUc[[5nUR [ 5(d[ X[ 5eX RRRU5 gr) rsr|rr,rrrrr"rrJs rMr@&IndividualVariableExpression._set_types^*d++++  #D)I!!+..&tE E--$$%,,T2r[c[$r)rrs rM _get_type&IndividualVariableExpression._get_typesr[cUR1$z:see: Expression.free()rfrs rMr}!IndividualVariableExpression.free r[c[5$rrrs rMr&IndividualVariableExpression.constantsrr[r$) r%r&r'r(r8rr@rrrr}rrJr$r[rMr`r`s1C$,t 3 Iy )Dr[r`c(\rSrSrSr\rSrSrSr g)rizsThis class represents variables that take the form of a single uppercase character followed by zero or more digits.cUR1$rrfrs rMr}FunctionVariableExpression.freerr[c[5$rrrs rMr$FunctionVariableExpression.constantsrr[r$N) r%r&r'r(r8rrr}rrJr$r[rMrrs2 Dr[rc\rSrSrSr\rSrg)rjizwThis class represents variables that take the form of a single lowercase 'e' character followed by zero or more digits.r$N)r%r&r'r(r8 EVENT_TYPErrJr$r[rMrjrjs6 Dr[rjc6\rSrSrSr\r\S4SjrSr Sr Sr g)rizpThis class represents variables that do not take the form of a single character followed by zero or more digits.Nc [U[5(deUc[[5nU[:Xa[ nO1UnUR [ :waURUR 5nX RRH0nUR RU5nU(aM'[U5e X RRRU5 X RRH nX4lM gr) rsr|rr,rrrrrr"rrrs rMr@ConstantExpression._set_type s*d++++  #D)I  !$J#JyyK''// : }}112E++J7J:8>>3 --$$%,,T2}}112E#J3r[c[5$rrrs rMr}ConstantExpression.free%rr[cUR1$rrfrs rMrConstantExpression.constants)rr[r$) r%r&r'r(r8rrrr@r}rrJr$r[rMrrs"2 D#+t$0r[rc4[U[5(d SU-5e[UR5(a [ U5$[ UR5(a [ U5$[UR5(a [U5$[U5$)z This is a factory method that instantiates and returns a subtype of ``AbstractVariableExpression`` appropriate for the given variable. rM) rsrrnr"r`rorrprjrrfs rMr r .s{ h ) )L+AH+LL )+H55 HMM " ")(33 X]] # #&x00!(++r[cj\rSrSrSrSrSSjrSrSrSr Sr S r S r S r \RrS rg )VariableBinderExpressioni>zThis an abstract class for any Expression that binds a variable in an Expression. This includes LambdaExpressions and Quantified Expressionsc[U[5(d SU-5e[U[5(d SU-5eXlX lg)z[ :param variable: ``Variable``, for the variable :param term: ``Expression``, for the term rMrN)rsrrrrr%s rMr}!VariableBinderExpression.__init__BsJ (H--P/E/PP-$ ++M-F-MM+  r[c V[U[5(d SU-5e[U[5(d SU-5eURU:Xa_U(aV[U[5(d SU-5eUR URUR RXSU55$U$U(a@URUR5;a"UR[URS95nUR URUR RXX455$)rrMrz&%s is not a AbstractVariableExpressionT)rr) rsrrrrar5rrr}rOrvrTs rMr VariableBinderExpression.replaceLs (H--P/E/PP-*j11 % 2 1 ==H $!*.HII>  !!( U r[c [U[5(d SU-5eURXRR UR [ U5S55$)zRename all occurrences of the variable introduced by this variable binder in the expression to ``newvar``. :param newvar: ``Variable``, for the new variable rMT)rsrr5rrrr )r|newvars rMrO&VariableBinderExpression.alpha_convertjsT &(++L-Cf-LL+~~ II%%dmm5G5OQUV  r[cRURR5UR1- $r)rr}rrs rMr}VariableBinderExpression.freetsyy~~4==/11r[c[U[5(d SU-5eXR:Xa[$URR U5$r)rsrrrrrGrFs rMrG!VariableBinderExpression.findtypexsD(H--P/E/PP- }} $O99%%h/ /r[c4U"U"UR5/5$rrrps rMrbVariableBinderExpression.visit8DII./00r[cHU"URU"UR55$)z#:see: Expression.visit_structured())rrrps rMrS)VariableBinderExpression.visit_structureds$--$)))<==r[cb[XR5(d[XR5(a{URUR:XaURUR:H$[ UR5nURURR URU5:H$g)zvDefines equality modulo alphabetic variance. If we are comparing \x.M and \y.N, then check equality of M and N[x/y].F)rsr5rrr r)r|rOvarexs rMrPVariableBinderExpression.__eq__s{ dOO , , 5..0Q0Q}}.yyEJJ..+4==9yyEJJ$6$6u~~u$MMMr[c X:X+$rr$rNs rMrSVariableBinderExpression.__ne__rUr[)rrNr)r%r&r'r(r8r}rrOr}rGrbrSrPrSrrbrJr$r[rMr r >sBO< 201> !""Hr[r c8\rSrSr\S5r\S4SjrSrSr g)ric[URRUR5URR5$r)rrrGrrrs rMrLambdaExpression.types*499--dmm.3Ataxrr)rrr5rr r)rr1r|rrs rMrfLambdaExpression.__str__s]]O yynn.   T]] +99Dnn. MMhh333 4jj Tk  r[r$ r%r&r'r(rrrr@rfrJr$r[rMrrs' NN$,t <  r[rc8\rSrSr\S5r\S4SjrSrSr g)QuantifiedExpressionic[$rrrs rMrQuantifiedExpression.typer[Nc[U[5(deUc[[5nUR [ 5(d[ X[ 5eURR[ U5 gr rsr|rr,rrrrr@rJs rMr@QuantifiedExpression._set_typeW*d++++  #D)I!!*--&tD D J 2r[ctUR/nURnURUR:XaCURUR5 URnURUR:XaMCUR 5S-SR SU55-[ R-SU--$)Nrc3,# UH nSU-v M g7frr$r(s rMr/QuantifiedExpression.__str__..r*rr)rrr5r getQuantifierrr r1r+s rMrfQuantifiedExpression.__str__s]]O yynn.   T]] +99Dnn.     hh333 4jj Tk   r[r$r-r$r[rMr/r/s% $,t 3  r[r/c\rSrSrSrSrg)ric"[R$r)r r+rs rMr;ExistsExpression.getQuantifiers }}r[r$Nr%r&r'r(r;rJr$r[rMrrsr[rc\rSrSrSrSrg)ric"[R$r)r r-rs rMr;AllExpression.getQuantifier zzr[r$Nr@r$r[rMrrsr[rc\rSrSrSrSrg)ric"[R$r)r r/rs rMr;IotaExpression.getQuantifiers {{r[r$Nr@r$r[rMrrsr[rct\rSrSrSr\S5r\S4SjrSr Sr Sr S r S r \RrS rS rg) ricN[U[5(d SU-5eXlgr)rsrr)r|rs rMr}NegatedExpression.__init__s%$ ++M-F-MM+ r[c[$rr1rs rMrNegatedExpression.typer3r[Nc[U[5(deUc[[5nUR [ 5(d[ X[ 5eURR[ U5 grr5rJs rMr@NegatedExpression._set_typer7r[cv[U[5(d SU-5eURRU5$)NrM)rsrrrGrFs rMrGNegatedExpression.findtypes5(H--P/E/PP-yy!!(++r[c4U"U"UR5/5$rrrps rMrbNegatedExpression.visitrr[cUR$)z:see: Expression.negate()rrs rMrNegatedExpression.negates yyr[cb[U[5=(a URUR:H$r)rsrrrNs rMrPNegatedExpression.__eq__s"%!23O UZZ8OOr[c X:X+$rr$rNs rMrSNegatedExpression.__ne__ rUr[cB[RSUR--$r~)r r5rrs rMrfNegatedExpression.__str__szzD499,,,r[r)r%r&r'r(r}rrrr@rGrbrrPrSrrbrfrJr$r[rMrrsS$,t 3,1P!""H-r[rcf\rSrSrSr\S5rSrSrSr Sr \ Rr Sr S rS rg ) BinaryExpressionic[U[5(d SU-5e[U[5(d SU-5eXlX lgr)rsrrrrs rMr}BinaryExpression.__init__sH%,,O.G%.OO,&*--Q/H6/QQ-  r[c[$rr1rs rMrBinaryExpression.typer3r[c[U[5(d SU-5eURRU5nURRU5nX#:Xd U[ :XaU$U[ :XaU$[ $r)rsrrrGrr)r|rrrAs rMrGBinaryExpression.findtypesi(H--P/E/PP- JJ   ) KK  * 6Q(]H (]HOr[cVU"U"UR5U"UR5/5$rrrps rMrbBinaryExpression.visit*s$8DJJ/$++1FGHHr[c[XR5=(d [XR5=(a9 URUR:H=(a URUR:H$r)rsr5rrrNs rMrPBinaryExpression.__eq__.sK oo . S*UNN2S , ekk) , u||+ r[c X:X+$rr$rNs rMrSBinaryExpression.__ne__5rUr[cURUR5nURUR5n[RU-S-UR 5-S-U-[R -$)Nr) _str_subexrrr r2getOpr3rs rMrfBinaryExpression.__str__:sX +-{{U"S(4::<7#=FUUr[c SU-$r~r$)r|subexs rMrjBinaryExpression._str_subex?s e|r[rN)r%r&r'r(r}rrrGrbrPrSrrbrfrjrJr$r[rMr\r\sH  I !""HV r[r\c"\rSrSr\S4SjrSrg)riCNc*[U[5(deUc[[5nUR [ 5(d[ X[ 5eURR[ U5 URR[ U5 gr) rsr|rr,rrrrr@rrJs rMr@BooleanExpression._set_typeDsk*d++++  #D)I!!*--&tD D Z3 j)4r[r$)r%r&r'r(rr@rJr$r[rMrrCs #+t 5r[rc$\rSrSrSrSrSrSrg)riQz"This class represents conjunctionsc"[R$r)r r7rs rMrkAndExpression.getOpTrDr[cDSU-n[U[5(aUSS$U$Nrrir)rsrr|rnrAs rMrjAndExpression._str_subexWs( 5L e] + +Qr7Nr[r$Nr%r&r'r(r8rkrjrJr$r[rMrrQs,r[rc$\rSrSrSrSrSrSrg)ri^z"This class represents disjunctionsc"[R$r)r r9rs rMrkOrExpression.getOpa yyr[cDSU-n[U[5(aUSS$U$rw)rsrrxs rMrjOrExpression._str_subexds( 5L e\ * *Qr7Nr[r$Nrzr$r[rMrr^s,r[rc\rSrSrSrSrSrg)rikz"This class represents implicationsc"[R$r)r r;rs rMrkImpExpression.getOpnrDr[r$Nr%r&r'r(r8rkrJr$r[rMrrks ,r[rc\rSrSrSrSrSrg)rirz$This class represents biconditionalsc"[R$r)r r=rs rMrkIffExpression.getOpurDr[r$Nrr$r[rMrrrs .r[rc,\rSrSrSr\S4SjrSrSrg)riyz:This class represents equality expressions like "(x = y)".Nc*[U[5(deUc[[5nUR [ 5(d[ X[ 5eURR[U5 URR[U5 gr) rsr|rr,rrrrr@rrrJs rMr@EqualityExpression._set_type|sk*d++++  #D)I!!*--&tD D [)4 k95r[c"[R$r)r r?rs rMrkEqualityExpression.getOpr~r[r$) r%r&r'r(r8rr@rkrJr$r[rMrrysD#+t 6r[rc\rSrSrSrSrg)ric:Xl[RX5 gr)r Exceptionr}r|rrs rMr}#LogicalExpressionException.__init__s 4)r[)rNr%r&r'r(r}rJr$r[rMrrs*r[rc\rSrSrSSjrSrg)riNcU(aU(a SU<SU<S3nO!U(aSU-nU(aUSU-- nOSU-n[RXU5 g)NzUnexpected token: 'z'. Expected token 'rzUnexpected token: '%s'.z r+rr})r|r unexpectedr-rrs rMr}!UnexpectedTokenException.__init__sO (C+j8Ctg~%(83C"++D=r[r$)NNNrr$r[rMrrs >r[rc\rSrSrSSjrSrg)riNcHU(dSn[RXSU-5 g)NzMore tokens expected.zEnd of input found. rrs rMr}$ExpectedMoreTokensException.__init__s#-G"++ 07: r[r$rrr$r[rMrrs r[rcr[U[5(d SU-5e[R"SU5SL$)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 rJz ^[a-df-z]\d*$NrsrKrGrHr;s rMrnrns9 dC ="6"== 88$d +4 77r[cr[U[5(d SU-5e[R"SU5SL$)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 rJz ^[A-Z]\d*$Nrrs rMroros8 dC ="6"== 88M4 ( 44r[cr[U[5(d SU-5e[R"SU5SL$)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 rJz^e\d*$Nrrs rMrprps8 dC ="6"== 88It $D 00r[c[Rn[S5 [U"S55 [U"S55 [U"S55 [U"S55 [U"S55 [U"S55 [U"S55 [U"S 55 [U"S 55 [U"S 55 [U"S 55 [U"S 55 [U"S55 [U"S55 [U"S55 [S5 [U"S5R55 [U"S5R55 [U"S5R55 [U"S5R55 [S5 U"S5n[U5 UR [ S55n[U5 [X:H5 g)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)rrrVr1rOr)lexpre1e2s rMdemors  ! !E -. %. %  %  %0 12 %9 :; %  %" #$ %! "# %& '( %. /0 %! "# %# $% %# $% %. /0 %% &' /0 %. / 8 8 :; %. / 8 8 :; %? @ I I KL %H I R R TU VW  B "I  (3- (B "I "(Or[c8[S5 [S5 [S5 [S5 [S5 [S5 [S5 [S5 [S 5 [S 5 [S 5 [S 5 [S 5 [S5 g)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)rV demoExceptionr$r[rM demo_errorsrst 45.!%&*%&'(+$)*+/"r[c[RU5 g![a.n[URR SU35 SnAgSnAff=f)Nr3)rrrrVr5r%)rArs rMrrsF.a %. %%&b,--.s A$A  AcT[UR5SUR35 g)Nz : )rVrKr)exs rM printtyper s RVVXJc"'' #$r[__main__)NNr)Kr8rZrG collectionsr functoolsrrnltk.internalsr nltk.utilrrrqr rZr_rdrfrGrrvrzr|rrrrrrrrrrrrrrrrrrrrrar`rrjrr r rr/rrrrr\rrrrrrrrrrnrorprrrrr%r$r[rMrs  #,"  9*I*IZ"""i@i@X<,,,@ 8   2B$2Bj&Y iB  l [ 9 >I   m  =   $$,H,$H,VGAJGATH$H$H$V#=< !; :$3$N , Z#zZ#z / < 3 >+ ( ) )- )-X-z-` 5( 5 %  $ %%),** >9 >  "<  8 5 1B#".% zFr[