B `e@sxdZddlZddlmZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZm Z ddlmZmZGdd d eZGd d d eZGd d d eZGdddeZddZddZd3ddZddZ ddZ!ddZ"ddZ#Gddde$Z%d4d d!Z&d"d#Z'Gd$d%d%eZ(Gd&d'd'eZ)Gd(d)d)e$Z*d*d+Z+d,d-Z,d.d/Z-d0d1Z.e/d2krte.dS)5z; Module for a resolution-based First Order theorem prover. N) defaultdict)reduce) skolemize) VariableExpressionEqualityExpressionApplicationExpression ExpressionNegatedExpressionVariable AndExpressionunique_variable OrExpression is_indvarIndividualVariableExpressionr)ProverBaseProverCommandc@s eZdZdS)ProverParseErrorN)__name__ __module__ __qualname__rrH/home/dcms/DCMS/lib/python3.7/site-packages/nltk/inference/resolution.pyr$src@s&eZdZdZdZd ddZddZdS) ResolutionProverZANSWERTNFc Cs|sg}d}yXg}|r&|t| x|D]}|t|q,W||\}}|rbtt|WnRtk r}z4|jrt| drd}g}n|rt|n|Wdd}~XYnX||fS)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 assumptionsverboseresultclausesaerrr_prove,s*  zResolutionProver._provecCstt}d}x|t|kr||s||r@||dd}n|d}x|t|kr||kr|r||s|||||||}|rx8|D]0}|d|df|_||t|sd|fSqWd}P|d7}qJW|d7}qWd|fS)NrTF)rlistlen is_tautologyappendunify_parents)r#r(Ztriedij newclauses newclauserrrrMs,      zResolutionProver._attempt_proof)NNF)rrr ANSWER_KEYr r+rrrrrr(s !rc@s6eZdZd ddZd ddZd ddZed d ZdS)rNcCs8|dk rt|tstnt}t||||d|_dS)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) isinstancerAssertionErrorr__init___clauses)r#r$r%Zproverrrrr;os z ResolutionProverCommand.__init__FcCs@|jdkr:|j|||\|_}||_t||_|jS)zh Perform the actual proof. Store the result to prevent unnecessary re-proving. N) Z_resultZ_proverr+r$r%r<rrZ_proof)r#r&r(rrrproves   zResolutionProverCommand.provecCsl||t}tttj}xH|jD]>}x8|D]0}t|tr0|j |kr0t|j t s0| |j q0Wq&W|S)N) r=setrr rr8r<r9rfunctionargumentradd)r#r&ZanswersZ answer_exclausetermrrr find_answerss      z$ResolutionProverCommand.find_answerscCsd}tdd|D}ttt|}xtt|D]}d}d}||rPd}||jrht||j}d|tt||d|}d|tt|dt|d}|d|||||f7}q4W|S) z, Decorate the proof output. cSsg|]}tt|qSr)r/r!).0rBrrr sz=ResolutionProverCommand._decorate_clauses..AZ Tautology r-z[%s] %s %s %s )maxr/r!ranger0r3)r(outZmax_clause_lenZ max_seq_lenr4parentsZtautseqrrrrs   $z)ResolutionProverCommand._decorate_clauses)NNN)F)F)rrrr;r=rD staticmethodrrrrrrns  rc@sveZdZddZdddZddZd d Zd d Zd dZddZ ddZ ddZ ddZ ddZ ddZddZdS)ClausecCst||d|_d|_dS)N)r.r; _is_tautologyr3)r#datarrrr;s zClause.__init__NFc Cs|dkrt}|dkrggf}|dkr.ggf}t|tr@t|}t|||||t|}g}xVt|D]J\}} ||krbx8t|D],\} } || kr|| |kr|| | r||| q|WqbWg} x*t t |D]}||kr| ||qW| S)a 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 N) BindingDictr9bool DebugObject_iterate_first_complete_unify_path enumeratesubsumesr1rKr/) r#otherbindingsusedskippeddebugr6Zsubsumedr4Zc1r5c2r'rrrr2s* z Clause.unifycCsx|D]}||krdSqWdS)z Return True iff every term in 'self' is a term in 'other'. :param other: ``Clause`` :return: bool FTr)r#rZr)rrr isSubsetOfs zClause.isSubsetOfc Csxg}x0|D](}t|tr&||jq || q Wt|}t}ggf}ggf}td}tt|||||t |dkS)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) r9r r1rCrPrSrUr/rV_subsumes_finalize) r#rZZ negatedotheratomZnegatedotherClauser[r\r]r^rrrrYs(   zClause.subsumescCstt|||S)N)rPr. __getslice__)r#startendrrrrcszClause.__getslice__cstfdd|DS)Ncsg|]}|kr|qSrr)rFr))rZrrrGsz"Clause.__sub__..)rP)r#rZr)rZr__sub__szClause.__sub__cCstt||S)N)rPr.__add__)r#rZrrrrgszClause.__add__cCs|jdk r|jSxt|D]z\}}t|tst|d}xZ||kr||}t|trj|j|krd|_dSnt|tr||jkrd|_dS|d8}q:WqWd|_dS)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. Nr-TF)rQrXr9rr/r rC)r#r4r)r5brrrr0 s$        zClause.is_tautologycCsttjdd|DS)Ncss|]}||BVqdS)N)free constants)rFrbrrr 9szClause.free..)roperatoror_)r#rrrri8sz Clause.freecstfdd|DS)z Replace every instance of variable with expression across every atom in the clause :param variable: ``Variable`` :param expression: ``Expression`` csg|]}|qSr)replace)rFrb) expressionvariablerrrGCsz"Clause.replace..)rP)r#rpror)rorprrn;szClause.replacecstfdd|DS)z Replace every binding :param bindings: A list of tuples mapping Variable Expressions to the Expressions to which they are bound :return: ``Clause`` csg|]}|qSr)substitute_bindings)rFrb)r[rrrGMsz.Clause.substitute_bindings..)rP)r#r[r)r[rrqEszClause.substitute_bindingscCsdddd|DdS)N{z, css|]}d|VqdS)z%sNr)rFitemrrrrkPsz!Clause.__str__..})join)r#rrr__str__OszClause.__str__cCsd|S)Nz%sr)r#rrr__repr__RszClause.__repr__)NNNF)rrrr;r2r`rYrcrfrgr0rirnrqrvrwrrrrrPs / &  rPc Cs$|d|||ft|r$t|s6|||||||St|||||||d}|d|dg|df}|t|dd||||||d7}yxt|d|d||\} } } |dd|d| d} |dd|d| d} |t| | | | ggf||d7}Wntk rYnX|SdS)zF This method facilitates movement through the terms of 'self' zunify(%s,%s) %sr-rN)liner/_iterate_secondrV _unify_termsBindingException)firstsecondr[r\r]finalize_methodr^r' newskipped newbindingsnewusedunusednewfirst newsecondrrrrVVs0 rVc Cs|d|||ft|r$t|s6|||||||S|d|d|dgf}t||dd|||||d}yxt|d|d||\} } } |dd|d| d} |dd|d| d} |t| | | | ggf||d7}Wntk rYnX|SdS)zG This method facilitates movement through the terms of 'other' zunify(%s,%s) %srr-N)rxr/ryrzr{)r|r}r[r\r]r~r^rr'rrrrrrrrrys,rycCsdt|tstt|tst|dkr*t}|dkr:ggf}t|trt|trt|j||}|d|g|d|gf}ggf}nt|trt|trt||j|}|d|g|d|gf}ggf}nt|tr t|j j |j fg}|d|g|df}g|gf}nNt|trNt|j j |j fg}|d|d|gf}|ggf}n t ||f|||fS)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 Nrr-) r9rr:rSr rmost_general_unificationrCrr|rpr}r{)r)rhr[r\rrrrrrrzs0        rzcCsX|ds|drFt|d|d||}|d|||gS|dgSdS)Nrr-z -> New Clause: %sz -> End)rPrxrq)r|r}r[r\r]r^r7rrrrWs   rWcCs"t|dst|sdgSgSdS)NrT)r/)r|r}r[r\r]r^rrrrasracCsZg}xPtt|D]@}x0|D]$}t|jr tt}|||}q W||qW|S)zC Skolemize, clausify, and standardize the variables apart. ) _clausifyrrirnamerr rnr1)roZ clause_listrBriZnewvarrrrrs  rcCst|trt|jt|jSt|trnt|j}t|j}t|dksLtt|dks\t|d|dgSt|trt |ggSt|t rt |ggSt|t rt|j t rt |ggSt|j trt |ggSt dS)z; :param expression: a skolemized expression in CNF r-rN)r9r rr|r}r r/r:rrPrr rCr)ror|r}rrrrs$             rc@sNeZdZdddZddZddZdd Zd d Zd d ZddZ ddZ dS)rSNcCs(i|_|r$x|D]\}}|||<qWdS)z :param binding_list: list of (``AbstractVariableExpression``, ``AtomicExpression``) to initialize the dictionary N)d)r#Z binding_listvrhrrrr;szBindingDict.__init__cCst|tstt|tsty ||}Wntk r@d}YnX|rN||krZ||j|<nnt|try||j}Wntk rd}YnXt|}|r||kr||j|j<qt d|n t d|dS)a 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) r9r r:rKeyErrorrrrprr{)r#rpZbindingexistingZbinding2rrr __setitem__s(         zBindingDict.__setitem__cCsJt|tst|j|}x,|rDy|j|}Wqtk r@|SXqWdS)zD Return the expression to which 'variable' is bound N)r9r r:rr)r#rpZ intermediaterrr __getitem__Es zBindingDict.__getitem__cCs ||jkS)N)r)r#rsrrr __contains__RszBindingDict.__contains__cCspyFt}x|jD]}|j|||<qWx|jD]}|j|||<q.W|Stk rjtd||fYnXdS)a :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 z?Attempting to add two contradicting BindingDicts: '%s' and '%s'N)rSrr{)r#rZZcombinedrrrrrgUs  zBindingDict.__add__cCs t|jS)N)r/r)r#rrr__len__hszBindingDict.__len__cs.dfddtjD}d|dS)Nz, c3s |]}d|j|fVqdS)z%s: %sN)r)rFr)r#rrrklsz&BindingDict.__str__..rrrt)rusortedrkeys)r#Zdata_strr)r#rrvks"zBindingDict.__str__cCsd|S)Nz%sr)r#rrrrwoszBindingDict.__repr__)N) rrrr;rrrrgrrvrwrrrrrSs ' rScCs|dkrt}||kr|St|tr0t|||St|trFt|||St|trzt|trzt|j|j|t|j|j|St||fdS)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 N) rSr9r_mgu_varrrr?r@r{)r)rhr[rrrrss      rcCs<|j||Bkr$t||fnt|j|fg|SdS)N)rprirjr{rS)varror[rrrrsrc@seZdZddZdS)r{cCs,t|trt|d|n t||dS)Nz'%s' cannot be bound to '%s')r9tuple Exceptionr;)r#argrrrr;s zBindingException.__init__N)rrrr;rrrrr{sr{c@seZdZddZdS)UnificationExceptioncCst|d||fdS)Nz'%s' cannot unify with '%s')rr;)r#r)rhrrrr;szUnificationException.__init__N)rrrr;rrrrrsrc@s&eZdZd ddZddZddZd S) rUTrcCs||_||_dS)N)enabledindent)r#rrrrrr;szDebugObject.__init__cCst|j|j|S)N)rUrr)r#r4rrrrgszDebugObject.__add__cCs|jrtd|j|dS)Nz )rrr)r#rxrrrrxszDebugObject.lineN)Tr)rrrr;rgrxrrrrrUs rUc Cs&tdtdtdtdtdtdtdtdtdtdtdtdtd td td }td }td }td|||t|||gftd}td}td}td|||t|||gftd}td}td||t||gfdS)Nzman(x)z(man(x) -> 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)z%s, %s |- %s: %szall 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)z %s |- %s: %s)resolution_testr fromstringrrr=)p1p2cprrrtestResolutionProvers2   "   "  rcCs*t|}t|}td||fdS)Nz |- %s: %s)rrrr=r)r*ftrrrrs  rcCstj}tt|dtt|dtt|dtt|dtt|dtt|dtt|dtt|dtt|d tt|d tt|d tt|d tt|d tt|dtt|dtt|dtt|ddS)Nz P(x) | Q(x)z(P(x) & Q(x)) | R(x)zP(x) | (Q(x) & R(x))z(P(x) & Q(x)) | (R(x) & S(x))zP(x) | Q(x) | R(x)zP(x) | (Q(x) & R(x)) | S(x)zexists x.P(x) | Q(x)z-(-P(x) & Q(x))z P(x) <-> 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))))rrrr)Zlexprrrr test_clausifys$rcCs:tttttd}tt||gdS)Nzman(x))rrrrrrr=)rrrrdemos  r__main__)NN)N)0__doc__rl collectionsr functoolsrZnltk.semrZnltk.sem.logicrrrrr r r r r rrZnltk.inference.apirrrrrrr.rPrVryrzrWrarrobjectrSrrr{rrUrrrrrrrrr s<   8FB',' .  `