B `H@s0dZddlmZddlmZddlmZmZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZmZGdddeZd d ZGd d d eZGd ddeZGdddeZ GdddeZ!Gddde"Z#ddZ$ddZ%ddZ&ddZ'ddZ(dd Z)d!d"Z*e+d#kr,e*d$S)%z A module to perform nonmonotonic reasoning. The ideas and demonstrations in this module are based on "Logical Foundations of Artificial Intelligence" by Michael R. Genesereth and Nils J. Nilsson. ) defaultdict)reduce)Prover9Prover9Command)VariableExpressionEqualityExpressionApplicationExpression ExpressionAbstractVariableExpression AllExpressionBooleanExpressionNegatedExpressionExistsExpressionVariable ImpExpression AndExpressionunique_variableoperator)ProverProverCommandDecoratorc@s eZdZdS)ProverParseErrorN)__name__ __module__ __qualname__rrJ/home/dcms/DCMS/lib/python3.7/site-packages/nltk/inference/nonmonotonic.pyr'srcCs4|dkr|}n || g}ttjdd|DtS)Ncss|]}|VqdS)N) constants).0arrr 0szget_domain..)rror_set)goal assumptionsZall_expressionsrrr get_domain+s r$c@s(eZdZdZddZddZddZdS) ClosedDomainProverz] This is a prover decorator that adds domain closure assumptions before proving. cs<ddjD}j}t||fdd|DS)NcSsg|]}|qSrr)rrrrr :sz2ClosedDomainProver.assumptions..csg|]}|qSr)replace_quants)rex)domainselfrrr&=s)_commandr#r"r$)r*r#r"r)r)r*rr#9s  zClosedDomainProver.assumptionscCs&|j}t||j}|||S)N)r+r"r$r#r')r*r"r)rrrr"?s zClosedDomainProver.goalcsttr>fddD}fdd|D}tdd|SttrhjjSttrj  Stt rfddD}fdd|D}tdd|SSd S) a Apply the closed domain assumption to the expression - Domain = union([e.free()|e.constants() for e in all_expressions]) - translate "exists x.P" to "(z=d1 | z=d2 | ... ) & P.replace(x,z)" OR "P.replace(x, d1) | P.replace(x, d2) | ..." - translate "all x.P" to "P.replace(x, d1) & P.replace(x, d2) & ..." :param ex: ``Expression`` :param domain: set of {Variable}s :return: ``Expression`` cs g|]}jjt|qSr)termreplacevariabler)rd)r(rrr&Qsz5ClosedDomainProver.replace_quants..csg|]}|qSr)r')rc)r)r*rrr&SscSs||@S)Nr)xyrrrTz3ClosedDomainProver.replace_quants..cs g|]}jjt|qSr)r,r-r.r)rr/)r(rrr&^scsg|]}|qSr)r')rr/)r)r*rrr&`scSs||BS)Nr)r1r2rrrr3ar4N) isinstancer rr __class__r'firstsecondr r,r)r*r(r)Z conjuncts disjunctsr)r)r(r*rr'Ds     z!ClosedDomainProver.replace_quantsN)rrr__doc__r#r"r'rrrrr%3sr%c@seZdZdZddZdS)UniqueNamesProverz[ This is a prover decorator that adds unique names assumptions before proving. c Cs|j}tt|j|}t}x4|D],}t|tr*|jj }|j j }|| |q*Wg}xvt |D]j\}}x`||ddD]L} | ||krtt |t | } t| |r|| | q|| qWqhW||S)z - Domain = union([e.free()|e.constants() for e in all_expressions]) - if "d1 = d2" cannot be proven from the premises, then add "d1 != d2" N)r+r#listr$r" SetHolderr5rr7r.r8add enumeraterrproveappend) r*r#r)Zeq_setsravZbvnew_assumptionsibZnewEqExrrrr#ls$    zUniqueNamesProver.assumptionsN)rrrr:r#rrrrr;fsr;c@seZdZdZddZdS)r>z& A list of sets of Variables. cCs@t|tstx|D]}||kr|SqWt|g}|||S)zV :param item: ``Variable`` :return: the set containing 'item' )r5rAssertionErrorr!rB)r*itemsnewrrr __getitem__s   zSetHolder.__getitem__N)rrrr:rKrrrrr>sr>c@s8eZdZdZddZddZddZdd Zd d Zd S) ClosedWorldProvera This is a prover decorator that completes predicates before proving. If the assumptions contain "P(A)", then "all x.(P(x) -> (x=A))" is the completion of "P". If the assumptions contain "all x.(ostrich(x) -> bird(x))", then "all x.(bird(x) -> ostrich(x))" is the completion of "bird". If the assumptions don't contain anything that are "P", then "all x.-P(x)" is the completion of "P". walk(Socrates) Socrates != Bill + all x.(walk(x) -> (x=Socrates)) ---------------- -walk(Bill) see(Socrates, John) see(John, Mary) Socrates != John John != Mary + all x.all y.(see(x,y) -> ((x=Socrates & y=John) | (x=John & y=Mary))) ---------------- -see(Socrates, Mary) all x.(ostrich(x) -> bird(x)) bird(Tweety) -ostrich(Sam) Sam != Tweety + all x.(bird(x) -> (ostrich(x) | x=Tweety)) + all x.-ostrich(x) ------------------- -bird(Sam) cCs\|j}||}g}x8|D].}||}||}dd|D}g}xN|jD]D} g} x&t|| D]\} } | t| | qfW|tdd| qRWxJ|j D]@} i}x"t|| dD]\} } | || <qW|| d |qW|r| ||}tdd|}t ||}nt | ||}x"|dddD]}t||}q2W||q W||S) NcSsg|] }t|qSr)r)rvrrrr&sz1ClosedWorldProver.assumptions..cSs||@S)Nr)r1r2rrrr3r4z/ClosedWorldProver.assumptions..rr<cSs||BS)Nr)r1r2rrrr3r4)r+r#_make_predicate_dict_make_unique_signature signaturesziprBrr propertiesZsubstitute_bindings_make_antecedentrr r )r*r# predicatesrDp predHoldernew_sigZ new_sig_exsr9sigZ equality_exsZv1Zv2propZbindings antecedentZ consequentaccumZ new_sig_varrrrr#s6        zClosedWorldProver.assumptionscCstddt|jDS)z This method figures out how many arguments the predicate takes and returns a tuple containing that number of unique variables. css|] }tVqdS)N)r)rrErrrrsz;ClosedWorldProver._make_unique_signature..)tuplerange signature_len)r*rWrrrrPsz(ClosedWorldProver._make_unique_signaturecCs"|}x|D]}|t|}q W|S)z Return an application expression with 'predicate' as the predicate and 'signature' as the list of arguments. )r)r* predicate signaturer[rMrrrrTs z"ClosedWorldProver._make_antecedentcCs&tt}x|D]}|||qW|S)z Create a dictionary of predicates from the assumptions. :param assumptions: a list of ``Expression``s :return: dict mapping ``AbstractVariableExpression`` to ``PredHolder`` )r PredHolder_map_predicates)r*r#rUrrrrrOs z&ClosedWorldProver._make_predicate_dictc CsHt|tr6|\}}t|tr2||t|nt|tr^||j|||j |nt|t rD|j g}|j }x t|t r| |j |j }qzWt|trDt|jtrDt|j trD|j\}}|j \} } t|trDt| trD|dd|DkrD|dd| DkrD|| t||jf|||dS)NcSsg|] }|jqSr)r.)rrMrrrr&'sz5ClosedWorldProver._map_predicates..cSsg|] }|jqSr)r.)rrMrrrr&(s)r5rZuncurryr append_sigr]rrcr7r8r r.r,rBr append_propvalidate_sig_len) r*Z expressionZpredDictfuncargsrYr,Zfunc1Zargs1Zfunc2Zargs2rrrrcs0            z!ClosedWorldProver._map_predicatesN) rrrr:r#rPrTrOrcrrrrrLs -  rLc@s@eZdZdZddZddZddZdd Zd d Zd d Z dS)rba This class will be used by a dictionary that will store information about predicates to be used by the ``ClosedWorldProver``. The 'signatures' property is a list of tuples defining signatures for which the predicate is true. For instance, 'see(john, mary)' would be result in the signature '(john,mary)' for 'see'. The second element of the pair is a list of pairs such that the first element of the pair is a tuple of variables and the second element is an expression of those variables that makes the predicate true. For instance, 'all x.all y.(see(x,y) -> know(x,y))' would result in "((x,y),('see(x,y)'))" for 'know'. cCsg|_g|_d|_dS)N)rQrSr_)r*rrr__init__>szPredHolder.__init__cCs|||j|dS)N)rfrQrB)r*rXrrrrdCs zPredHolder.append_sigcCs||d|j|dS)Nr)rfrSrB)r*Znew_proprrrreGszPredHolder.append_propcCs0|jdkrt||_n|jt|kr,tddS)NzSignature lengths do not match)r_len Exception)r*rXrrrrfKs  zPredHolder.validate_sig_lencCsd|j|j|jfS)Nz (%s,%s,%s))rQrSr_)r*rrr__str__QszPredHolder.__str__cCsd|S)Nz%sr)r*rrr__repr__TszPredHolder.__repr__N) rrrr:rirdrerfrlrmrrrrrb.srbc Cstj}|d}|d}|d}t|||g}t|t|}tdx|D]}td|qRWtd|t||d}|d}|d}|d}t||||g}t|t|}tdx|D]}td|qWtd|t||d}|d}|d}|d}t||||g}t|t|}tdx|D]}td|qVWtd|t||d}|d}|d }t|||g}t|t|}tdx|D]}td|qWtd|t||d }|d }|d }|d }|d} |d}t|||||| g}t|t|}tdx|D]}td|qhWtd|t|dS)Nzexists x.walk(x)z man(Socrates)zwalk(Socrates)z assumptions:z zgoal:z -walk(Bill)z walk(Bill)z all x.walk(x)z girl(mary)z dog(rover)zall x.(girl(x) -> -dog(x))zall x.(dog(x) -> -girl(x))zchase(mary, rover)z1exists y.(dog(y) & all x.(girl(x) -> chase(x,y))))r fromstringrprintrAr%r#r") lexprp1p2r0proverZcdprp3p4Zp5rrrclosed_domain_demoXsz         rvcCstj}|d}|d}|d}t|||g}t|t|}tdx|D]}td|qRWtd|t||d}|d}|d }|d }t||||g}t|t|}tdx|D]}td|qWtd|t|dS) Nz man(Socrates)z man(Bill)zexists x.exists y.(x != y)z assumptions:z zgoal:z!all x.(walk(x) -> (x = Socrates))zBill = Williamz Bill = Billyz-walk(William))r rnrrorAr;r#r")rprqrrr0rsZunprrtrrrunique_names_demos0   rwc Cstj}|d}|d}|d}t|||g}t|t|}tdx|D]}td|qRWtd|t||d}|d}|d }|d }|d }t|||||g}t|t|}tdx|D]}td|qWtd|t||d }|d }|d}|d}|d}t|||||g}t|t|}tdx|D]}td|qjWtd|t|dS)Nzwalk(Socrates)z(Socrates != Bill)z -walk(Bill)z assumptions:z zgoal:zsee(Socrates, John)zsee(John, Mary)z(Socrates != John)z(John != Mary)z-see(Socrates, Mary)zall x.(ostrich(x) -> bird(x))z bird(Tweety)z -ostrich(Sam)z Sam != Tweetyz -bird(Sam))r rnrrorArLr#r") rprqrrr0rsZcwprrtrurrrclosed_world_demosL     rxcCsrtj}|d}|d}|d}t|||g}t|ttt|}x|D] }t|qRWt|dS)Nzsee(Socrates, John)zsee(John, Mary)z-see(Socrates, Mary)) r rnrrorAr%r;rLr#)rprqrrr0rscommandrrrrcombination_prover_demos  rzcCs tj}g}||d||d||d||d||d||d||d||d||d ||d ||d ||d ||d ||dtd|}tt|}x|D] }t|qWtd|td|td|dS)Nz'all x.(elephant(x) -> animal(x))z'all x.(bird(x) -> animal(x))z%all x.(dove(x) -> bird(x))z%all x.(ostrich(x) -> bird(x))z(all x.(flying_ostrich(x) -> ostrich(x))z)all x.((animal(x) & -Ab1(x)) -> -fly(x))z(all x.((bird(x) & -Ab2(x)) -> fly(x))z)all x.((ostrich(x) & -Ab3(x)) -> -fly(x))z#all x.(bird(x) -> Ab1(x))z#all x.(ostrich(x) -> Ab2(x))z#all x.(flying_ostrich(x) -> Ab3(x))z elephant(E)zdove(D)z ostrich(O)z-fly(E)zfly(D)z-fly(O)) r rnrBrr;rLr#ro print_proof)rppremisesrsryrrrrdefault_reasoning_demos4        r}cCs8tj}t|||}tt|}t|||dS)N)r rnrr;rLrorA)r"r|rprsryrrrr{ s r{cCs"tttttdS)N)rvrwrxrzr}rrrrdemo's r~__main__N),r: collectionsr functoolsrZnltk.inference.prover9rrZnltk.sem.logicrrrr r r r r rrrrrrZnltk.inference.apirrrkrr$r%r;r=r>rLobjectrbrvrwrxrzr}r{r~rrrrr s,  @3+ *E,,