OfeSrSSKrSSKJr SSKJr SSKJrJr SSK J r SSK J r J r JrJrJrJrJrJrJrJrJr "SS \5r"S S \5r"S S \5r"SS\5rSrSrS&SjrSr Sr!Sr"Sr#"SS5r$S'Sjr%Sr&"SS\5r'"SS\5r("SS 5r)S!r*S"r+S#r,S$r-\.S%:Xa\-"5 gg)(z; Module for a resolution-based First Order theorem prover. N) defaultdict)reduce)BaseProverCommandProver) skolemize) AndExpressionApplicationExpressionEqualityExpression ExpressionIndividualVariableExpressionNegatedExpression OrExpressionVariableVariableExpression is_indvarunique_variablec\rSrSrSrg)ProverParseError"N)__name__ __module__ __qualname____firstlineno____static_attributes__r;/usr/lib/python3/dist-packages/nltk/inference/resolution.pyrr"srrc,\rSrSrSrSrSSjrSrSrg) ResolutionProver&ANSWERTNcU(d/nSn/nU(aUR[U*55 UHnUR[U55 M URU5upEU(a[[R U55 XE4$![ a\nUR(a*[U5RS5(a Sn/nSnAXE4$U(a[U5 SnAUW4$UeSnAff=f)z :param goal: Input expression to prove :type goal: sem.Expression :param assumptions: Input expressions to use as assumptions in the proof :type assumptions: list(sem.Expression) Nz maximum recursion depth exceededF) extendclausify_attempt_proofprintResolutionProverCommand_decorate_clauses RuntimeError _assume_falsestr startswith)selfgoal assumptionsverboseresultclausesaes r_proveResolutionProver._prove*sK Gx/ x{+!"11':OF-??HI   !!c!f&7&72''   !HH  G s$A?B C54C0C0.C00C5cH[[5nSnU[U5:aXR5(dX#(a X#SS-nOUS-nU[U5:aX4:waU(aXR5(dqX#R U5 XR X5nU(aBUH9nUS-US-4UlUR U5 [U5(aM5SU4s $ SnOUS- nU[U5:aMUS- nU[U5:aMSU4$)NrTF)rlistlen is_tautologyappendunify_parents)r-r2triedij newclauses newclauses rr%ResolutionProver._attempt_proofKsD! #g,:**,,8 q(AAA#g,&v!GJ,C,C,E,E*%,Z%5%5gj%A %-7 67!eQU^ 2 'y 9'*9~~,0'?$: .8 !#A!FA#g,& FA1#g,2wrr)NNF) rrrr ANSWER_KEYr*r5r%rrrrrr&sJM!B rrcB\rSrSrSSjrS SjrS Sjr\S5rSr g) r'lNcUb[U[5(deO [5n[R"XX5 SUlg)z :param goal: Input expression to prove :type goal: sem.Expression :param assumptions: Input expressions to use as assumptions in the proof. :type assumptions: list(sem.Expression) N) isinstancerr__init___clauses)r-r.r/provers rrK ResolutionProverCommand.__init__ms=  f&677 77%'F""4C rcURcaURRUR5UR 5U5uUlnX l[ RU5UlUR$)zP Perform the actual proof. Store the result to prevent unnecessary re-proving. ) _result_proverr5r.r/rLr'r(_proof)r-r0r2s rproveResolutionProverCommand.prove}sb << $(LL$7$7 T--/% !DL'$M1CCGLDK||rcURU5 [5n[[[R 55nUR HqnUHhn[U[5(dMURU:XdM,[UR[5(aMMURUR5 Mj Ms U$N) rSsetrrrrFrLrJr functionargumentr add)r-r0answers answer_exclauseterms r find_answers$ResolutionProverCommand.find_answerss 7%&x0@0K0K'LM mmFt%:;; 2&t}}6RSSKK . $rc Sn[SU55n[[[U555n[[U55HnSnSnXR 5(aSnXR (a[XR 5nSU[[X55- S--U-nSU[[US-55- -[US-5-nUSUSXSUSUS 3 - nM U$) z Decorate the proof output. c3J# UHn[[U55v M g7frV)r;r+).0r]s r .sDG&SV--Gs!#A Tautology r9[z]  )maxr;r+ranger<r?)r2outmax_clause_len max_seq_lenrAparentstautseqs rr()ResolutionProverCommand._decorate_clausess DGDD#c'l+, s7|$AGDz&&(("z""gj112^c#gj/.BBQFG'QGs3q1u:67#a!e*DC Qse2gj\7)1TF"= =C% r)rLrRrP)NNN)F) rrrrrKrSr_ staticmethodr(rrrrr'r'ls%  rr'cf\rSrSrSrSSjrSrSrSrSr S r S r S r S r S rSrSrSrg)ClausecJ[RX5 SUlSUlgrV)r:rK _is_tautologyr?)r-datas rrKClause.__init__s d!! rNc Uc [5nUc//4nUc//4n[U[5(a [U5n[ XX#U[ U5n/n[ U5HWupX;dM [ U5H<upX:wdM X;dMU RU 5(dM+URU 5 M> MY /n [[U55HnX;dM U RXh5 M U $)ap Attempt to unify this Clause with the other, returning a list of resulting, unified, Clauses. :param other: ``Clause`` with which to unify :param bindings: ``BindingDict`` containing bindings that should be used during the unification :param used: tuple of two lists of atoms. The first lists the atoms from 'self' that were successfully unified with atoms from 'other'. The second lists the atoms from 'other' that were successfully unified with atoms from 'self'. :param skipped: tuple of two ``Clause`` objects. The first is a list of all the atoms from the 'self' Clause that have not been unified with anything on the path. The second is same thing for the 'other' Clause. :param debug: bool indicating whether debug statements should print :return: list containing all the resulting ``Clause`` objects that could be obtained by unification ) BindingDictrJbool DebugObject_iterate_first_complete_unify_path enumeratesubsumesr=rmr;) r-otherbindingsusedskippeddebugrCsubsumedrAc1rBc2r1s rr> Clause.unifys&  "}H <8D ?2hG eT " "&E# 2F z*EA &z2EAv!"3 B *3+ s:'A  jm,( rc$UH nX!;dM g g)zd Return True iff every term in 'self' is a term in 'other'. :param other: ``Clause`` :return: bool FTrr-rr3s r isSubsetOfClause.isSubsetOfsA~rc 2/nUHGn[U[5(aURUR5 M5URU*5 MI [ U5n[ 5n//4n//4n[ S5n[[UUUUU[U55S:$)z Return True iff 'self' subsumes 'other', this is, if there is a substitution such that every term in 'self' can be unified with a term in 'other'. :param other: ``Clause`` :return: bool Fr) rJr r=r^rwr~rr;r_subsumes_finalize) r-r negatedotheratomnegatedotherClauserrrrs rrClause.subsumess D$ 122##DII.##TE*  $L1=Bxr(E" &&   rc@[[RXU55$rV)rwr: __getslice__)r-startends rrClause.__getslice__sd''S9::rcR[UVs/sH o"U;dM UPM sn5$s snfrV)rwrs r__sub__Clause.__sub__s#$9$Q5.q$9::9s $$c>[[RX55$rV)rwr:__add__)r-rs rrClause.__add__sdll4/00rcURb UR$[U5Hup[U[5(aM[ U5S- nX1:dM1Xn[U[ 5(aUR U:Xa SUl gO-[U[ 5(aX$R :Xa SUl gUS-nX1:aMlM SUlg)z Self is a tautology if it contains ground terms P and -P. The ground term, P, must be an exact match, ie, not using unification. r9TF)rzrrJr r;r r^)r-rAr3rBbs rr<Clause.is_tautologys    )%% %dODAa!344IMeA!!%67766Q;15D.#''$A'899;15D.#'FAe$#rcD[[RSU55$)Nc3b# UH%oR5UR5-v M' g7frV)free constants)rdrs rreClause.free..7s"$WRV$iikDNN4D&DRVs-/)roperatoror_r-s rr Clause.free6shll$WRV$WXXrc `[UVs/sHo3RX5PM sn5$s snf)z Replace every instance of variable with expression across every atom in the clause :param variable: ``Variable`` :param expression: ``Expression`` )rwreplace)r-variable expressionrs rrClause.replace9s(dKdd||H9dKLLK+c`[UVs/sHo"RU5PM sn5$s snf)z Replace every binding :param bindings: A list of tuples mapping Variable Expressions to the Expressions to which they are bound. :return: ``Clause`` )rwsubstitute_bindings)r-rrs rrClause.substitute_bindingsCs*dKdd//9dKLLKrc>SSRSU55-S-$)N{, c3,# UH nSU-v M g7f)%sNr)rditems rre!Clause.__str__..Nsrrrrrr<rrrrrrrrrrwrwsI -^ $ L;;10YMMCrrwc URSUSUSU35 [U5(a[U5(d U"XX#XF5$[XX#XEUS-5nUSUS/-US4nU[USSXX8XVS-5- n[ USUSX#5upn USSUS-U S-n USSUS-U S-n U[U U U U //4UUS-5- nU$![ a U$f=f)z> This method facilitates movement through the terms of 'self' unify(,) r9rN)liner;_iterate_secondr _unify_termsBindingException)firstsecondrrrfinalize_methodrr1 newskipped newbindingsnewusedunusednewfirst newseconds rrrTsM JJwaxr(45 u::S[[uhgMM! 87UQY  ajE!H:-wqz: . !"Iv?TUI   +7a&)X, (K& QRy71:-q 9Hqr WQZ/&);I nR  F      s?AC C C c URSUSUSU35 [U5(a[U5(d U"XX#XF5$USUSUS/-4n[XSSX#XuUS-5n[USUSX#5upn USSUS-U S-n USSUS-U S-n U[U U U U //4UUS-5- nU$![a U$f=f)z? This method facilitates movement through the terms of 'other' rrrrr9N)rr;rrr)rrrrrrrrr1rrrrrs rrrs- JJwaxr(45 u::S[[uhgMMaj'!*q {":;  !":xzETUI  +7a&)X, (K& QRy71:-q 9Hqr WQZ/&);I oR  F      s+AB>> C  C cX[U[5(de[U[5(deUc [5nUc//4n[U[5(aC[U[5(a.[ UR X5nUSU/-USU/-4n//4nGO [U[5(aB[U[5(a-[ XR U5nUSU/-USU/-4n//4nO[U[5(a@[URRUR4/5nUSU/-US4n/U/4nOa[U[5(a@[URRUR4/5nUSUSU/-4nU//4nO [X45eXEU4$)a This method attempts to unify two terms. Two expressions are unifiable if there exists a substitution function S such that S(a) == S(-b). :param a: ``Expression`` :param b: ``Expression`` :param bindings: ``BindingDict`` a starting set of bindings with which the unification must be consistent :return: ``BindingDict`` A dictionary of the bindings required to unify :raise ``BindingException``: If the terms cannot be unified rr9) rJr r~r r most_general_unificationr^r rrrr)r3rrrrrrs rrrs a $ $$ $ a $ $$ $= |Bx!&''Jq:O,P,P.qvvqC 7aS=$q'QC-0b A, - -*Q@Q2R2R.q&&(C 7aS=$q'QC-0b A) * *!AGG$4$4ahh#?"@A 7aS=$q'*qc A) * *!AGG$4$4ahh#?"@A 7DGqcM*#rv&&  ''rcUS(d US(a@[USUS-U-U-5nURSU-5 URU5/$URS5 /$)Nrr9z -> New Clause: %sz -> End)rwrr)rrrrrrrDs rrrsg Aw$q'71: 2U:VCD  (945--h788 : rcR[US5(d[U5(dS/$/$)NrT)r;)rrrrrrs rrrs% wqz??3u:: v  rc/n[[U55HknUR5HCn[UR5(dM[ [ 55nURX45nME URU5 Mm U$)z; Skolemize, clausify, and standardize the variables apart. ) _clausifyrrrnamerrrr=)r clause_listr]rnewvars rr$r$soKIj12KKMD##+O,=>5" 6" 3 rc[U[5(a+[UR5[UR5-$[U[ 5(aX[UR5n[UR5n[ U5S:Xde[ U5S:XdeUSUS-/$[U[5(a [U/5/$[U[5(a [U/5/$[U[5(aX[UR[5(a [U/5/$[UR[5(a [U/5/$[5e)z3 :param expression: a skolemized expression in CNF r9r) rJrrrrrr;r rwr r r^r)rrrs rrrs.*m,,))*Yz7H7H-III J - -***+:,,-5zQ6{aa6!9$%% J 2 3 3 |$%% J 5 6 6 |$%% J 1 2 2 joo'< = =J<() )  ); < <J<() )  rcH\rSrSrS SjrSrSrSrSrSr S r S r S r g) r~iNc@0UlU(aUH up#X0U'M gg)zr :param binding_list: list of (``AbstractVariableExpression``, ``AtomicExpression``) to initialize the dictionary Nd)r- binding_listvrs rrKBindingDict.__init__s& $Q% rc[U[5(de[U[5(deXnU(aX#:XaX RU'g[U[ 5(aMXR n[U5nU(aXC:XaX@RUR 'g[SU-5e[SU-5e![a SnNf=f![a SnNlf=f)aP A binding is consistent with the dict if its variable is not already bound, OR if its variable is already bound to its argument. :param variable: ``Variable`` The variable to bind :param binding: ``Expression`` The atomic to which 'variable' should be bound :raise BindingException: If the variable cannot be bound in this dictionary Nz*Variable %s already bound to another value) rJrr KeyErrorrr rrr)r-rbindingexistingbinding2s r __setitem__BindingDict.__setitem__s(H----':.... ~H7.&FF8  != > >  0 01*(3Hx3+3w''(&CxP#?8L + H   s#B?%C? C C C C c[U[5(deURUnU(aURUnU(aMgg![a Us$f=f)z4 Return the expression to which 'variable' is bound N)rJrrr)r-r intermediates r __getitem__BindingDict.__getitem__CsY(H----vvh'  $#vvl3 l $## $sA AAcXR;$rVr)r-rs r __contains__BindingDict.__contains__Psvv~rc[5nURHnURUX#'M URHnURUX#'M U$![an[SU<SU<S35UeSnAff=f)z :param other: ``BindingDict`` The dict with which to combine self :return: ``BindingDict`` A new dict containing all the elements of both parameters :raise BindingException: If the parameter dictionaries are not consistent with each other z3Attempting to add two contradicting BindingDicts: 'z' and ''N)r~rr)r-rcombinedrr4s rrBindingDict.__add__Ssy "}HVV"ffQi WW#ggaj O "15u>  sAA A: A55A:c,[UR5$rV)r;rrs r__len__BindingDict.__len__fs466{rc^SRU4Sj[TRR5555nSU-S-$)Nrc3J># UHoSTRU3v M g7f): Nr)rdrr-s rre&BindingDict.__str__..js$P:OQs"TVVAYK0:Os #rr)rsortedrkeys)r-data_strs` rrBindingDict.__str__is599P&:OPPX~##rc SU-$rrrs rrBindingDict.__repr__mrrrrV) rrrrrKrrrrrrrrrrrr~r~s+%N $&$rr~cUc [5nX:XaU$[U[5(a [XU5$[U[5(a [XU5$[U[5(aX[U[5(aC[ UR UR U5[ URURU5-$[X45e)aH Find the most general unification of the two given expressions :param a: ``Expression`` :param b: ``Expression`` :param bindings: ``BindingDict`` a starting set of bindings with which the unification must be consistent :return: a list of bindings :raise BindingException: if the Expressions cannot be unified ) r~rJr _mgu_varr rrXrYr)r3rrs rrrqs=v A3 4 4h'' A3 4 4h'' A, - -*Q@U2V2V' JJ H $QZZX FG G A6 ""rcURUR5UR5-;a [X45e[ URU4/5U-$rV)rrrrr~)varrrs rr r sM ||z(:+?+?+AAA011S\\:6788CCrc\rSrSrSrSrg)ric[U[5(a[RUSU-5 g[RX5 g)Nz'%s' cannot be bound to '%s')rJtuple ExceptionrK)r-args rrKBindingException.__init__s3 c5 ! !   t%Cc%I J   t )rrNrrrrrKrrrrrrs*rrc\rSrSrSrSrg)UnificationExceptionic>[RUSUSUS35 g)Nrz' cannot unify with ')rrK)r-r3rs rrKUnificationException.__init__s"41QC' man(x))z(man(x) -> --man(x))z-(man(x) and -man(x))z(man(x) or -man(x))z(man(x) iff man(x))z-(man(x) iff -man(x))z all x.man(x)z--all x.some y.F(x,y) & some x.all y.(-F(x,y))zsome x.all y.sees(x,y)zall x.(man(x) -> mortal(x))z man(Socrates)zmortal(Socrates)rz |- rzall x.(man(x) -> walks(x))z man(John)zsome y.walks(y)z5some e1.some e2.(believe(e1,john,e2) & walk(e2,mary))zsome e0.walk(e0,mary))resolution_testr fromstringr&rrS)p1p2cps rtestResolutionProverr+sI)*+,,-*+)*,-*+)**+,-N#CD,-   = >B   / 0B12A RD2$d1#R 0 2 8 8H EF GH   < =B   | ,B01A RD2$d1#R 0 2 8 8H EF GHVWA67A QCtA3b)+11!S9: ; Q(x)z-(P(x) <-> Q(x))z -(all x.P(x))z-(some x.P(x))z some x.P(x)zsome x.all y.P(x,y)zall y.some x.P(x,y)zall z.all y.some x.P(x,y,z)z1all x.(all y.P(x,y) -> -all y.(Q(x,y) -> R(x,y))))r r&r&r$)lexprs r test_clausifyr1sL  ! !E (5' () (5/0 12 (5/0 12 (589 :; (5-. /0 (567 89 (5/0 12 (5*+ ,- (5) *+ (5+, -. (5) *+ (5)* +, (5' () (5./ 01 (5./ 01 (567 89 (5LM NOrc[5 [5 [5 [5 [R"S5n[[ X/5R 55 g)Nr$)r1r&r+r r&r'rS)r*s rdemor3s@O G Gh'A !!S ) / / 12r__main__)NNrV)/__doc__r collectionsr functoolsrnltk.inference.apirrnltk.semrnltk.sem.logicrr r r r r rrrrrrrrr'r:rwrrrrrr$rr~rr rrrr+r%r1r3rrrrr;s#8     y C vC L?/?DcTcL)X$N+(\  0]]@#6D*y*C9C / /=> P43 zFr