U e_@svdZddlZddlZddlmZddlmZmZddlm Z ddl m Z dZ e Z Gdd d Zd d Zd d ZddZGdddZdwddZeGdddZdxddZdyddZGdddZGdddeZGdddeZGd d!d!eZGd"d#d#eZGd$d%d%eZGd&d'd'eeZeZeZeZ eZ!d(d)Z"Gd*d+d+e#Z$Gd,d-d-e$Z%Gd.d/d/e$Z&Gd0d1d1e$Z'dzd2d3Z(Gd4d5d5Z)Gd6d7d7e)Z*Gd8d9d9e*Z+eGd:d;d;e*Z,Gdd?d?e,Z.Gd@dAdAe-Z/GdBdCdCe,Z0dDdEZ1GdFdGdGe*Z2GdHdIdIe2Z3GdJdKdKe2Z4GdLdMdMe4Z5GdNdOdOe4Z6GdPdQdQe4Z7GdRdSdSe*Z8GdTdUdUe*Z9GdVdWdWe9Z:GdXdYdYe:Z;GdZd[d[e:ZGd`dadae9Z?Gdbdcdce#Z@Gdddedee@ZAGdfdgdge@ZBdhdiZCdjdkZDdldmZEdndoZFdpdqZGdrdsZHdtduZIeJdvkrreFdS){zV A version of first order predicate logic, built on top of the typed lambda calculus. N) defaultdict)reducetotal_ordering)Counter)TrieAPPc@seZdZdZdgZdZdddgZdZddgZdZ dgZ dZ d Z d Z d Zd Zd d dgZdZdddgZdZddgZdZdddgZdZdddgZdZddgZdZdgZeeeeZeee Ze e e egZeeeeeeeZ dde DZ!dS) Tokens\existsZsomeexistallforalliota.(),-not!&and^|orz->Zimpliesz=>z<->Ziffz<=>=z==z!=cCsg|]}td|r|qS)z^[-\\.(),!&^|>=<]*$)rematch.0xr!O/var/www/html/assets/scripts/venv/lib/python3.8/site-packages/nltk/sem/logic.py Es zTokens.N)"__name__ __module__ __qualname__LAMBDA LAMBDA_LISTEXISTS EXISTS_LISTALLALL_LISTIOTA IOTA_LISTDOTOPENCLOSECOMMANOTNOT_LISTANDAND_LISTOROR_LISTIMPIMP_LISTIFFIFF_LISTEQEQ_LISTNEQNEQ_LISTZBINOPSQUANTSZPUNCTTOKENSSYMBOLSr!r!r!r"rs>       rcCsBdddddg}t|tjtjtjtjtjgD]}td|q,dS)z Boolean operators ZnegationZ conjunctionZ disjunctionZ implicationZ equivalence%-15s %sN)ziprr3r5r7r9r;printnamespairr!r!r" boolean_opsHs"rJcCs0ddg}t|tjtjgD]}td|qdS)z Equality predicates ZequalityZ inequalityrDN)rErr=r?rFrGr!r!r"equality_predsQsrKcCs:dddg}t|tjtjtjtjgD]}td|q$dS)z Binding operators Z existential universallambdarDN)rErr)r+r'r-rFrGr!r!r" binding_opsZs rNc@seZdZdZdFddZdGddZdd Zd d Zd d ZddZ dHddZ ddZ ddZ ddZ ddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Zdd?Z!d@dAZ"dBdCZ#dDdEZ$dS)I LogicParserz$A lambda calculus expression parser.FcCst|tstd|_g|_||_g|_tddtj Dddtj Dt dfgddtj tj DddtjDddtjDd dtjDd dtjDd dtjDd g|_t g|_d S)z :param type_check: should type checking be performed to their types? :type type_check: bool rcSsg|] }|dfqS)r!rr!r!r"r#~sz(LogicParser.__init__..cSsg|] }|dfqS)r!rr!r!r"r#scSsg|] }|dfqS)r!rr!r!r"r#scSsg|] }|dfqS)r!rr!r!r"r#scSsg|] }|dfqS)r!rr!r!r"r#scSsg|] }|dfqS)r!rr!r!r"r#scSsg|] }|dfqS)r!rr!r!r"r#scSsg|] }|dfqS) r!rr!r!r"r#s)N N) isinstanceboolAssertionError _currentIndex_buffer type_check quote_charsdictrr(r4rr>r@rAr6r8r:r<operator_precedenceright_associated_operations)selfr_r!r!r"__init__fs6   zLogicParser.__init__Nc Cs|}d|_||\|_}z.|d}|drJt|jd|dWnJtk r}z,d ||d||j d}td||W5d}~XYnX|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 rNrPz {} {} {}^ ) rstripr]processr^process_next_expressioninRangeUnexpectedTokenExceptiontokenLogicalExpressionExceptionformatindexr_ typecheck)rddata signaturemappingresultemsgr!r!r"parses    zLogicParser.parsec Csg}i}t|}d}d}|}|t|krF|}|||\} }| rX|sN|}|| 7}q |} ||} d} | | kr| | 7} | | } t||t| kr||t| } qhqqhtj| kr|r||t|<||d}||t|<|| |t| 7}q ||dkr&|r<||t|<||d}n|s0|}|||7}|d7}q |rb||t|<||t||t|<t|d|t|d<||fS)zSplit the data into tokensrz rP)rget_all_symbolslenprocess_quoted_tokenZLEAFappend) rdrqoutrsZ tokenTrierldata_idxZtoken_start_idxZ cur_data_idxZ quoted_tokenstcsymbolr!r!r"rhs\            zLogicParser.processc Csd}||}|}|jD]\}}}} ||kr| r6||7}|d7}|||kr|||kr| rf|||7}|d7}t||krtdd||||7}n |||7}|d7}t||kr>tdd|q>| r|||7}|d7}|stddqq||fS)NrxrPz:End of input reached. Escape character [%s] found at end.z%End of input reached. Expected: [%s]zEmpty quoted token found)r`rzrm) rdr~rqrlristartendescapeZ incl_quotesr!r!r"r{sF        z LogicParser.process_quoted_tokencCstjS)z#This method exists to be overridden)rrCrdr!r!r"ryszLogicParser.get_all_symbolscCs|j|t|jkS)z6Return TRUE if the given location is within the buffer)r]rzr^)rdlocationr!r!r"rjszLogicParser.inRangec Csrz:|dkr&|j|j}|jd7_n|j|j|}|WStk rl}zt|jd|W5d}~XYnXdS)zGet the next waiting token. If a location is given, then return the token at currentIndex+location without advancing currentIndex; setting it gives lookahead/lookback capability.NrP)r^r] IndexErrorExpectedMoreTokensException)rdrtokrur!r!r"rls zLogicParser.tokencCs |tjkSN)rrBrdrr!r!r" isvariableszLogicParser.isvariablec Cspz |}Wn6tk rB}zt|jddd|W5d}~XYnX|||}|sdt|j|dd|||S)zAParse the next complete expression from the stream and return it.rPExpression expected.messageN)rlrr]handlerkattempt_adjuncts)rdcontextrruaccumr!r!r"ris"  z#LogicParser.process_next_expressioncCsr||r|||S|tjkr,|||S|tjkrB|||S|tjkrX|||S|tj krn| ||SdS)zgThis method is intended to be overridden for logics that use different operators or expressionsN) rhandle_variablerr4handle_negationr( handle_lambdarA handle_quantr0 handle_openrdrrr!r!r"r+s         zLogicParser.handlecCs>d}||jkr:|j}|||}|||}|||}q|Sr)r]attempt_EqualityExpressionattempt_ApplicationExpressionattempt_BooleanExpression)rd expressionrZcur_idxr!r!r"r=s   zLogicParser.attempt_adjunctscCs||tjSr)make_NegatedExpressionrirr3rr!r!r"rFszLogicParser.handle_negationcCst|SrNegatedExpression)rdrr!r!r"rIsz"LogicParser.make_NegatedExpressioncCs||}|dr|dtjkrt|tsHt|tsHt|j d||| || t }|dr|dtj kr|| || t }qb|tj|S)NrzW'%s' is an illegal predicate name. Individual variables may not be used as predicates.)make_VariableExpressionrjrlrr0rZFunctionVariableExpressionConstantExpressionrmr]make_ApplicationExpressionrirr2assertNextTokenr1rdrrrr!r!r"rLs2   zLogicParser.handle_variablec Csjz |}Wn0tk r<}zt|jd|W5d}~XYnXt||trbt|jd||ft|S)NzVariable expected.z;'%s' is an illegal variable name. Constants may not be %s.) rlrrorZrrrmr]Variable)rd descriptionrrur!r!r"get_next_token_variablejs  z#LogicParser.get_next_token_variablecCs|dst|jddd|dg}|drL|dtjkr^|ds^t|jddd||dspq||dq(|dr|dtjkr|| |}|r| | |}q|S)NrrQz;Variable and Expression expected following lambda operator.rZ abstractedrPr) rjrr]rrlrr/rr|rimake_LambdaExpressionpop)rdrrvarsrr!r!r"rws0    zLogicParser.handle_lambdacCs||}|ds*t|jdd|d|dg}|drZ|dtjkrl|dslt|jddd||ds~q| |dq6|dr|dtjkr|| |}|r| || |}q|S)NrrQz;Variable and Expression expected following quantifier '%s'.rZ quantifiedrPr) get_QuantifiedExpression_factoryrjrr]rrlrr/rr|rimake_QuanifiedExpressionr)rdrrfactoryrrr!r!r"rs6     zLogicParser.handle_quantcCs<|tjkrtS|tjkrtS|tjkr*tS||tjdS)z\This method serves as a hook for other logic parsers that have different quantifiersN) rr*ExistsExpressionr, AllExpressionr.IotaExpression assertTokenrArr!r!r"rs   z,LogicParser.get_QuantifiedExpression_factorycCs |||Srr!)rdrvariabletermr!r!r"rsz$LogicParser.make_QuanifiedExpressioncCs|d}|tj|Sr)rirrr1rr!r!r"rs  zLogicParser.handle_opencCsb|dr^|d}|tjtjkr^|||r^|||||}|tjkr^||}|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) rjrlrr>r@ has_prioritymake_EqualityExpressionrir)rdrrrr!r!r"rs    z&LogicParser.attempt_EqualityExpressioncCs t||S)zlThis method serves as a hook for other logic parsers that have different equality expression classes)EqualityExpressionrdfirstsecondr!r!r"rsz#LogicParser.make_EqualityExpressioncCsT|drP|d}||}|rP|||rP||||||}qqPq|S)zAttempt to make a boolean expression. If the next token is a boolean operator, then a BooleanExpression will be returned. Otherwise, the parameter will be returned.r)rjrlget_BooleanExpression_factoryrmake_BooleanExpressionri)rdrrrrr!r!r"rs   z%LogicParser.attempt_BooleanExpressioncCs@|tjkrtS|tjkrtS|tjkr*tS|tjkr8tSdSdS)zbThis method serves as a hook for other logic parsers that have different boolean operatorsN) rr6 AndExpressionr8 OrExpressionr: ImpExpressionr< IffExpressionrr!r!r"rs    z)LogicParser.get_BooleanExpression_factorycCs |||Srr!)rdrrrr!r!r"rsz"LogicParser.make_BooleanExpressioncCs|t|r|dr|dtjkrt|tsbt|tsbt|t sbt|t sbt |j d|d|| ||t}|dr|dtjkr|| ||t}q||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.)rrrjrlrr0rZLambdaExpressionApplicationExpressionrrrmr]rrir2rr1)rdrrrr!r!r"rs<  z)LogicParser.attempt_ApplicationExpressioncCs t||Sr)rrdfunctionargumentr!r!r"rsz&LogicParser.make_ApplicationExpressioncCs tt|Sr)VariableExpressionrrdnamer!r!r"r"sz#LogicParser.make_VariableExpressioncCs t||Sr)rrdrrr!r!r"r%sz!LogicParser.make_LambdaExpressioncCs2|j||j|kp0||jko0|j||j|kSr)rbrc)rdZ operationrr!r!r"r(s   zLogicParser.has_priorityc Csz |}Wn6tk rB}zt|jd|d|W5d}~XYnXt|trf||kr|t|j||n||kr|t|j||dS)NExpected token '%s'.r)rlrrorZlistrkr])rdexpectedrrur!r!r"r0s  zLogicParser.assertNextTokencCs<t|tr"||kr8t|j||n||kr8t|j||dSr)rZrrkr])rdrrr!r!r"r?s  zLogicParser.assertTokencCs6|drd|d}nd}d|jjd|dS)Nrz Next token: zNo more tokens<: >)rjrl __class__r$rdrvr!r!r"__repr__Gs zLogicParser.__repr__)F)N)N)%r$r%r&__doc__rerwrhr{ryrjrlrrirrrrrrrrrrrrrrrrrrrrrrrrr!r!r!r"rOcsD % 6$    #rOc Cs|dk r||}|dkr t}g}t|D]r\}}|}|ds0|dkrTq0z|||Wq0tk r}zt d|d||W5d}~XYq0Xq0|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#rxzUnable to parse line r) decoderO enumerate splitlinesstrip startswithr|rwrm ValueError)sZ logic_parserencodingZ statementsZlinenumlinerur!r!r" read_logicOs  *rc@sLeZdZddZddZddZddZd d Zd d Zd dZ ddZ dS)rcCs t|tstd|||_dS)z7 :param name: the name of the variable %s is not a stringN)rZstrr\rrr!r!r"reoszVariable.__init__cCst|to|j|jkSr)rZrrrdotherr!r!r"__eq__vszVariable.__eq__cCs ||k Srr!rr!r!r"__ne__yszVariable.__ne__cCst|tst|j|jkSr)rZr TypeErrorrrr!r!r"__lt__|s zVariable.__lt__cCs |||Sr)getrdbindingsr!r!r"substitute_bindingsszVariable.substitute_bindingscCs t|jSr)hashrrr!r!r"__hash__szVariable.__hash__cCs|jSrrrr!r!r"__str__szVariable.__str__cCs d|jS)NzVariable('%s')rrr!r!r"rszVariable.__repr__N) r$r%r&rerrrrrrrr!r!r!r"rmsrcCs|dk rFt|jrd}qJt|jr(d}qJt|jr8d}qJdsJtdnd}t|t}|dk r||krt|t}q^|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 NzFZe0Fz!Cannot generate a unique constant) is_indvarr is_funcvar is_eventvarr\r_counterr)patternignoreprefixvr!r!r"unique_variables    rcCs6ttdt}|r2t|D]}|t|}q |S)zX Return a skolem function over the variables in univ_scope param univ_scope zF%s)rrrrr)Z univ_scopeZskolemrr!r!r"skolem_functions  rc@s(eZdZddZddZeddZdS)TypecCsd|SN%sr!rr!r!r"rsz Type.__repr__cCs td|Sr)rrr!r!r"rsz Type.__hash__cCst|Sr) read_type)clsrr!r!r" fromstringszType.fromstringN)r$r%r&rr classmethodrr!r!r!r"rsrc@sJeZdZddZddZddZejZddZd d Z d d Z d dZ dS) ComplexTypecCs<t|tstd|t|ts,td|||_||_dS)Nz%s is not a Type)rZrr\rrrr!r!r"reszComplexType.__init__cCs"t|to |j|jko |j|jkSr)rZrrrrr!r!r"rs    zComplexType.__eq__cCs ||k Srr!rr!r!r"rszComplexType.__ne__cCs2t|tr&|j|jo$|j|jS|tkSdSr)rZrrmatchesrANY_TYPErr!r!r"rs zComplexType.matchescCs^|tkr |St|trJ|j|j}|j|j}|rD|rDt||SdSn|tkrV|SdSdSr)rrZrrresolver)rdrfrr!r!r"rs  zComplexType.resolvecCs*|tkrdtSd|jd|jdSdS)Nrrrr)rrrrr!r!r"rszComplexType.__str__cCs2|tkrtSd|jd|jdSdS)Nrz -> r)rrrrrr!r!r"rszComplexType.strN) r$r%r&rerrrrrrrrr!r!r!r"rsrc@s2eZdZddZddZejZddZddZd S) BasicTypecCst|tod|d|kSr)rZr rr!r!r"rszBasicType.__eq__cCs ||k Srr!rr!r!r"rszBasicType.__ne__cCs|tkp||kSr)rrr!r!r"rszBasicType.matchescCs||r|SdSdSr)rrr!r!r"rs zBasicType.resolveN) r$r%r&rrrrrrr!r!r!r"r s r c@seZdZddZddZdS) EntityTypecCsdS)Nrur!rr!r!r"r szEntityType.__str__cCsdS)NZINDr!rr!r!r"rszEntityType.strNr$r%r&rrr!r!r!r"r  sr c@seZdZddZddZdS)TruthValueTypecCsdS)Ntr!rr!r!r"rszTruthValueType.__str__cCsdS)NZBOOLr!rr!r!r"rszTruthValueType.strNr r!r!r!r"r sr c@seZdZddZddZdS) EventTypecCsdS)Nrr!rr!r!r"rszEventType.__str__cCsdS)NZEVENTr!rr!r!r"rsz EventType.strNr r!r!r!r"rsrc@sbeZdZddZeddZeddZddZd d Ze j Z d d Z d dZ ddZ ddZdS)AnyTypecCsdSrr!rr!r!r"re#szAnyType.__init__cCs|Srr!rr!r!r"r&sz AnyType.firstcCs|Srr!rr!r!r"r*szAnyType.secondcCst|tp||Sr)rZrrrr!r!r"r.szAnyType.__eq__cCs ||k Srr!rr!r!r"r1szAnyType.__ne__cCsdS)NTr!rr!r!r"r6szAnyType.matchescCs|Srr!rr!r!r"r9szAnyType.resolvecCsdS)N?r!rr!r!r"r<szAnyType.__str__cCsdS)NANYr!rr!r!r"r?sz AnyType.strN)r$r%r&repropertyrrrrrrrrrrr!r!r!r"r"s  rcCst|tst|dd}|ddkr|ddks6td}t|D]L\}}|dkr\|d7}qB|dkrz|d8}|dkstqB|dkrB|dkrBqqBtt|d|t||ddS|dd tkrtS|dd tkrtS|dd t krt St dd |ddS) NrfrxrrrrPrrzUnexpected character: '%s'.) rZrr\replacerrr ENTITY_TYPE TRUTH_TYPErrm)Z type_stringZ paren_countrcharr!r!r"rIs8    rcseZdZfddZZS) TypeExceptioncst|dSrsuperrerrr!r"reiszTypeException.__init__r$r%r&re __classcell__r!r!rr"rhsrcseZdZdfdd ZZS)"InconsistentTypeHierarchyExceptionNcs*|rd||f}nd|}t|dS)NzLThe variable '%s' was found in multiple places with different types in '%s'.zDThe variable '%s' was found in multiple places with different types.r)rdrrrvrr!r"rensz+InconsistentTypeHierarchyException.__init__)Nrr!r!rr"rmsrcseZdZfddZZS)TypeResolutionExceptioncstd||j|fdS)Nz9The type of '%s', '%s', cannot be resolved with type '%s')rretype)rdr other_typerr!r"re}s  z TypeResolutionException.__init__rr!r!rr"r|srcseZdZfddZZS)IllegalTypeExceptioncs td|jj|||fdS)Nz9Cannot set type of %s '%s' to '%s'; must match type '%s'.)rrerr$)rdrr!Z allowed_typerr!r"res zIllegalTypeException.__init__rr!r!rr"r"sr"cCs4|D]}||}q|ddD]}||q |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)rp)Z expressionsrrrr!r!r"rps   rpc@s eZdZdZddZddZdS)SubstituteBindingsIzT An interface for classes that can perform substitutions for variables. cCs tdS)z :return: The object that is obtained by replacing each variable bound by ``bindings`` with its values. Aliases are already resolved. (maybe?) :rtype: (any) NNotImplementedErrorrr!r!r"rsz'SubstituteBindingsI.substitute_bindingscCs tdS)zB :return: A list of all variables in this object. Nr$rr!r!r" variablesszSubstituteBindingsI.variablesN)r$r%r&rrr&r!r!r!r"r#s r#c@seZdZdZeZeddZed@ddZdd Z d d Z d d Z ddZ ddZ ddZddZddZddZddZdAddZddZd d!ZdBd"d#Zd$d%Zedfd&d'ZdCd(d)ZdDd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Z d6d7Z!d8d9Z"d:d;Z#dd?Z%dS)E Expressionz 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`` r/Nr)Prover9)rZr'r\Znltk.inferencer6rsimplifyZprove)rdrZproverr6Zbicondr!r!r"equivs  zExpression.equivcCs tt|Sr)rreprrr!r!r"rszExpression.__hash__cCsn|}|D]X}||kr ||}t|tr6||}nt|tsNtd|f||}|||}q |S)Nz@Can not substitute a non-expression value into an expression: %r) r&rZrrr'rrrr7)rdrexprvarvalr!r!r"rs     zExpression.substitute_bindingscsrtt|rT|D]B}||}tt|}t|tr:||_n t||_||q|j dfddDS)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 )rrcsi|]}||djqS)r)r )rkeysigr!r" 'sz(Expression.typecheck..) rrrrrZrr rr| _set_type)rdrrr=r<varExr!r>r"rps    zExpression.typecheckcCs tdS)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 Nr$rdrr!r!r"findtype)szExpression.findtypecCs tdS)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)) Nr$rdr!rrr!r!r"rA2szExpression._set_typecsHttstdtts,td|fdd|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 Variabler/cs|Sr)rru alpha_convertr replace_boundrr!r"Jz$Expression.replace..)rZrr\r'visit_structuredrrdrrrJrIr!rHr"r<s zExpression.replacecsfdd|}tt|dddD]`\}}t|trR|td|d}n&t|trt|td|d}n|}||j|d }q(|S) z&Rename auto-generated unique variablescs4t|tr|hSt|tr tS|ddSdS)NcSsttj|tSrroperatoror_setpartsr!r!r"rKXrLz>Expression.normalize..get_indiv_vars..)rZIndividualVariableExpressionAbstractVariableExpressionrRvisitrGget_indiv_varsr!r"rYQs  z,Expression.normalize..get_indiv_varscSs|jSrrrGr!r!r"rK\rLz&Expression.normalize..)r=ze0%srPzz%sT) rsortedrZEventVariableExpressionrrrUrr)rdZnewvarsrtrruZnewVarr!rXr" normalizeNs    zExpression.normalizecCs tdS)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`` Nr$rdr combinatorr!r!r"rWfszExpression.visitcs||fddS)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 cs|Srr!rSr_r!r"rKrLz-Expression.visit_structured..rWr^r!r`r"rMws zExpression.visit_structuredcCsd|jjd|dS)Nrrfr)rr$rr!r!r"rszExpression.__repr__cCs|Sr)rrr!r!r"rszExpression.__str__cCs"|dd||BDBS)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 cSsh|]}td|jr|qS)z^[?@])rrr)rpr!r!r" sz'Expression.variables..)free predicates constantsrr!r!r"r&s zExpression.variablescCs|ddddS)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 cSs|Sr)rdrGr!r!r"rKrLz!Expression.free..cSsttj|tSrrOrSr!r!r"rKrLrarr!r!r"rdszExpression.freecCs|ddddS)zu Return a set of individual constants (non-predicates). :return: set of ``Variable`` objects cSs|Sr)rfrGr!r!r"rKrLz&Expression.constants..cSsttj|tSrrOrSr!r!r"rKrLrarr!r!r"rfszExpression.constantscCs|ddddS)zu Return a set of predicates (constants, not variables). :return: set of ``Variable`` objects cSs|Sr)rerGr!r!r"rKrLz'Expression.predicates..cSsttj|tSrrOrSr!r!r"rKrLrarr!r!r"reszExpression.predicatescCs|dd|jS)zD :return: beta-converted version of this expression cSs|Sr)r7rGr!r!r"rKrLz%Expression.simplify..)rMrrr!r!r"r7szExpression.simplifycCst|Sr)rrCr!r!r"rsz"Expression.make_VariableExpression)FN)N)N)FT)N)&r$r%r&rrOr)r(rrr-r*r0r1r2r3r4rrrr8rrrprDrrArr]rWrMrrr&rdrfrer7rr!r!r!r"r'sB           r'c@seZdZdZddZddZeddZedfd d Z d d Z d dZ ddZ ddZ ddZddZejZddZddZeddZeddZdd ZdS)!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)". cCs<t|tstd|t|ts,td|||_||_dS)z :param function: ``Expression``, for the function expression :param argument: ``Expression``, for the argument r/N)rZr'r\rrrr!r!r"reszApplicationExpression.__init__cCsB|j}|j}t|tr2|j|j|S|||SdSr) rr7rrZrrrrrrr!r!r"r7s    zApplicationExpression.simplifycCs t|jjtr|jjjStSdSr)rZrr rrrrr!r!r"r s zApplicationExpression.typeNc Cst|tst|dkrtt}|jt|z|jt |jj ||WnLt k r}z.t d|j|jj |j|jj |jj j f|W5d}~XYnXdS):see Expression._set_type()NzqThe function '%s' is of type '%s' and cannot be applied to '%s' of type '%s'. Its argument must match type '%s'.)rZrr\rrrrArrrr rrr)rdr!rrrur!r!r"rAs,  zApplicationExpression._set_typecsttstd|r,|\}}n|j}|jg}fdd|g|D}g}|D]4}|tkrZ|r|D]}||rnqqnqZ| |qZt |dkrt |dStSdS):see Expression.findtype()rFcsg|]}|qSr!)rDrargrZr!r"r#sz2ApplicationExpression.findtype..rPrN) rZrr\is_atomuncurryrrrrr|rzr)rdrrargsfounduniquerur!rZr"rD s"    zApplicationExpression.findtypecCs,t|jtrt}n |j}||jBSz:see: Expression.constants())rZrrVrRrfr)rdZfunction_constantsr!r!r"rf's  zApplicationExpression.constantscCs0t|jtr|jjh}n |j}||jBSz:see: Expression.predicates())rZrrrrer)rdZfunction_predsr!r!r"re/s   z ApplicationExpression.predicatescCs|||j||jgSz:see: Expression.visit())rrr^r!r!r"rW7szApplicationExpression.visitcCs"t|to |j|jko |j|jkSr)rZrrrrr!r!r"r;s    zApplicationExpression.__eq__cCs ||k Srr!rr!r!r"rBszApplicationExpression.__ne__cCs|r*|\}}ddd|D}n|j}d|j}d|}d}t|trt|jtrpt|jjt sd}qt|jt sd}nt|trd}|rt j |t j }|t j |t j S)Nrcss|]}d|VqdSrNr!rir!r!r" Ksz0ApplicationExpression.__str__..rFT)rkrljoinrrrZrrrrVBooleanExpressionrr0r1)rdrrmZarg_strZ function_strZparenthesize_functionr!r!r"rGs$      zApplicationExpression.__str__cCs6|j}|jg}t|tr.|d|j|j}q||fS)zh Uncurry this application expression return: A tuple (base-function, arg-list) r)rrrZrinsert)rdrrmr!r!r"rlas  zApplicationExpression.uncurrycCs |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. rrlrr!r!r"predoszApplicationExpression.predcCs |dS)z+ Return uncurried arg-list rPryrr!r!r"rmxszApplicationExpression.argscCs t|jtS)zk Is this expression an atom (as opposed to a lambda expression applied to a term)? )rZrzrVrr!r!r"rkszApplicationExpression.is_atom)r$r%r&rrer7rr rrArDrfrerWrrr'rrrlrzrmrkr!r!r!r"rs(    rc@sneZdZdZddZddZddd Zed fd d Zd dZ ddZ ddZ ddZ ddZ ejZddZd S)rVzDThis class represents a variable to be used as a predicate or entitycCs t|tstd|||_dS)zA :param variable: ``Variable``, for the variable rFN)rZrr\rrCr!r!r"resz#AbstractVariableExpression.__init__cCs|Srr!rr!r!r"r7sz#AbstractVariableExpression.simplifyFTcCsBt|tstd|t|ts,td||j|kr:|S|SdS):see: Expression.replace()z%s is not an Variabler/N)rZrr\r'rrNr!r!r"rs  z"AbstractVariableExpression.replaceNcCszt|tst|dkrtt}|}||jjD]}|j|}|s.t |q.||jj |||jjD] }||_qjdSrgN) rZrr\rrrrr rrr|rdr!rr resolutionrBr!r!r"rAs  z$AbstractVariableExpression._set_typecCs.t|tstd||j|kr&|jStSdSrhrFN)rZrr\rr rrCr!r!r"rDs z#AbstractVariableExpression.findtypecCstSrrrRrr!r!r"resz%AbstractVariableExpression.predicatescCst|to|j|jkS)zTAllow equality between instances of ``AbstractVariableExpression`` subtypes.)rZrVrrr!r!r"rs  z!AbstractVariableExpression.__eq__cCs ||k Srr!rr!r!r"rsz!AbstractVariableExpression.__ne__cCst|tst|j|jkSr)rZrVrrrr!r!r"rs z!AbstractVariableExpression.__lt__cCs d|jSrrZrr!r!r"rsz"AbstractVariableExpression.__str__)FT)r$r%r&rrer7rrrArDrerrrr'rrr!r!r!r"rVs rVc@s@eZdZdZedfddZddZeeeZddZ d d Z dS) rUzThis class represents variables that take the form of a single lowercase character (other than 'e') followed by zero or more digits.NcCsJt|tst|dkrtt}|ts4t||t||jj  |dSr|) rZrr\rrrrr"rrr|rEr!r!r"rAs   z&IndividualVariableExpression._set_typecCstSr)rrr!r!r" _get_typesz&IndividualVariableExpression._get_typecCs|jhSz:see: Expression.free()rZrr!r!r"rdsz!IndividualVariableExpression.freecCstSrqrrr!r!r"rfsz&IndividualVariableExpression.constants) r$r%r&rrrArrr rdrfr!r!r!r"rUs   rUc@s$eZdZdZeZddZddZdS)rzwThis class represents variables that take the form of a single uppercase character followed by zero or more digits.cCs|jhSrrZrr!r!r"rdszFunctionVariableExpression.freecCstSrqrrr!r!r"rfsz$FunctionVariableExpression.constantsN)r$r%r&rrr rdrfr!r!r!r"rsrc@seZdZdZeZdS)r\z{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_TYPEr r!r!r!r"r\sr\c@s2eZdZdZeZedfddZddZddZ dS) rztThis class represents variables that do not take the form of a single character followed by zero or more digits.NcCst|tst|dkrtt}|tkr,t}n|}|jtkrF||j}||j j D]}|j|}|sRt |qR||j j  |||j j D] }||_qdSr|) rZrr\rrrrr rrrrr|r}r!r!r"rA s    zConstantExpression._set_typecCstSrrrr!r!r"rd%szConstantExpression.freecCs|jhSrqrZrr!r!r"rf)szConstantExpression.constants) r$r%r&rrr rrArdrfr!r!r!r"rs rcCsXt|tstd|t|jr(t|St|jr:t|St|jrLt |St |SdS)z This is a factory method that instantiates and returns a subtype of ``AbstractVariableExpression`` appropriate for the given variable. rFN) rZrr\rrrUrrrr\rrZr!r!r"r.s   rc@s`eZdZdZddZdddZdd Zd d Zd d ZddZ ddZ ddZ ddZ e jZdS)VariableBinderExpressionzThis an abstract class for any Expression that binds a variable in an Expression. This includes LambdaExpressions and Quantified ExpressionscCs<t|tstd|t|ts,td|||_||_dS)zs :param variable: ``Variable``, for the variable :param term: ``Expression``, for the term rFr/N)rZrr\r'rrrr!r!r"reBsz!VariableBinderExpression.__init__FTc Cst|tstd|t|ts,td||j|krr|rlt|tsPtd|||j|j||d|S|Sn@|r|j| kr| t |jd}||j|j||||SdS)r{rFr/z&%s is not a AbstractVariableExpressionT)rN) rZrr\r'rrVrrrrdrIrrNr!r!r"rLs(   z VariableBinderExpression.replacecCs4t|tstd||||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 rFT)rZrr\rrrrr)rdZnewvarr!r!r"rIjs z&VariableBinderExpression.alpha_convertcCs|j|jhSr)rrdrrr!r!r"rdtszVariableBinderExpression.freecCs4t|tstd|||jkr$tS|j|SdSr)rZrr\rrrrDrCr!r!r"rDxs z!VariableBinderExpression.findtypecCs|||jgSrsrr^r!r!r"rWszVariableBinderExpression.visitcCs||j||jS)z#:see: Expression.visit_structured())rrr^r!r!r"rMsz)VariableBinderExpression.visit_structuredcCsZt||jst||jrR|j|jkr0|j|jkSt|j}|j|j|j|kSndSdS)z~Defines equality modulo alphabetic variance. If we are comparing \x.M and \y.N, then check equality of M and N[x/y].FN)rZrrrrr)rdrZvarexr!r!r"rs    zVariableBinderExpression.__eq__cCs ||k Srr!rr!r!r"rszVariableBinderExpression.__ne__N)FT)r$r%r&rrerrIrdrDrWrMrrr'rr!r!r!r"r>s   rc@s.eZdZeddZedfddZddZdS)rcCst|j|j|jjSr)rrrDrr rr!r!r"r szLambdaExpression.typeNcCsHt|tst|dkrtt}|j|j||j |sDt ||dSr|) rZrr\rrrrArr rrrEr!r!r"rAs  zLambdaExpression._set_typecCsV|jg}|j}|j|jkr.||j|j}qtjddd|Dtjd|S)Nrfcss|]}d|VqdSrtr!rrr!r!r"rusz+LambdaExpression.__str__..r)rrrr|rr'rvr/rdr&rr!r!r"rs  zLambdaExpression.__str__r$r%r&rr rrArr!r!r!r"rs  rc@s.eZdZeddZedfddZddZdS)QuantifiedExpressioncCstSrrrr!r!r"r szQuantifiedExpression.typeNcCsFt|tst|dkrtt}|ts4t||t|j t|dSr| rZrr\rrrrr"rrArEr!r!r"rAs   zQuantifiedExpression._set_typecCs\|jg}|j}|j|jkr.||j|j}q|dddd|Dtjd|S)Nrfcss|]}d|VqdSrtr!rr!r!r"rusz/QuantifiedExpression.__str__..r)rrrr| getQuantifierrvrr/rr!r!r"rs  zQuantifiedExpression.__str__rr!r!r!r"rs  rc@seZdZddZdS)rcCstjSr)rr)rr!r!r"rszExistsExpression.getQuantifierNr$r%r&rr!r!r!r"rsrc@seZdZddZdS)rcCstjSr)rr+rr!r!r"rszAllExpression.getQuantifierNrr!r!r!r"rsrc@seZdZddZdS)rcCstjSr)rr-rr!r!r"rszIotaExpression.getQuantifierNrr!r!r!r"rsrc@sdeZdZddZeddZedfddZdd Zd d Z d d Z ddZ ddZ e jZddZdS)rcCs t|tstd|||_dSr.)rZr'r\r)rdrr!r!r"reszNegatedExpression.__init__cCstSrrrr!r!r"r szNegatedExpression.typeNcCsFt|tst|dkrtt}|ts4t||t|j t|dSr|rrEr!r!r"rAs   zNegatedExpression._set_typecCs"t|tstd||j|S)NrF)rZrr\rrDrCr!r!r"rDszNegatedExpression.findtypecCs|||jgSrsrr^r!r!r"rWszNegatedExpression.visitcCs|jS)z:see: Expression.negate()rrr!r!r"r1szNegatedExpression.negatecCst|to|j|jkSr)rZrrrr!r!r"rszNegatedExpression.__eq__cCs ||k Srr!rr!r!r"r szNegatedExpression.__ne__cCstjd|jSr)rr3rrr!r!r"rszNegatedExpression.__str__)r$r%r&rerr rrArDrWr1rrr'rrr!r!r!r"rs  rc@sVeZdZddZeddZddZddZd d Zd d Z e j Z d dZ ddZ dS)BinaryExpressioncCs<t|tstd|t|ts,td|||_||_dSr.)rZr'r\rrrr!r!r"reszBinaryExpression.__init__cCstSrrrr!r!r"r szBinaryExpression.typecCsVt|tstd||j|}|j|}||ks>|tkrB|S|tkrN|StSdSr)rZrr\rrDrr)rdrrrr!r!r"rDs  zBinaryExpression.findtypecCs|||j||jgSrs)rrr^r!r!r"rW*szBinaryExpression.visitcCs0t||jst||jo.|j|jko.|j|jkSr)rZrrrrr!r!r"r.s   zBinaryExpression.__eq__cCs ||k Srr!rr!r!r"r5szBinaryExpression.__ne__cCs<||j}||j}tj|d|d|tjS)Nrf) _str_subexrrrr0getOpr1rr!r!r"r:s  zBinaryExpression.__str__cCsd|Srr!)rdsubexr!r!r"r?szBinaryExpression._str_subexN)r$r%r&rerr rDrWrrr'rrrr!r!r!r"rs  rc@seZdZedfddZdS)rwNcCsTt|tst|dkrtt}|ts4t||t|j t||j t|dSr|) rZrr\rrrrr"rrArrEr!r!r"rADs  zBooleanExpression._set_type)r$r%r&rrAr!r!r!r"rwCsrwc@s eZdZdZddZddZdS)rz"This class represents conjunctionscCstjSr)rr5rr!r!r"rTszAndExpression.getOpcCs"d|}t|tr|ddS|SNrrPr)rZrrdrrr!r!r"rWs  zAndExpression._str_subexNr$r%r&rrrr!r!r!r"rQsrc@s eZdZdZddZddZdS)rz"This class represents disjunctionscCstjSr)rr7rr!r!r"raszOrExpression.getOpcCs"d|}t|tr|ddS|Sr)rZrrr!r!r"rds  zOrExpression._str_subexNrr!r!r!r"r^src@seZdZdZddZdS)rz"This class represents implicationscCstjSr)rr9rr!r!r"rnszImpExpression.getOpNr$r%r&rrr!r!r!r"rksrc@seZdZdZddZdS)rz$This class represents biconditionalscCstjSr)rr;rr!r!r"ruszIffExpression.getOpNrr!r!r!r"rrsrc@s&eZdZdZedfddZddZdS)rz:This class represents equality expressions like "(x = y)".NcCsTt|tst|dkrtt}|ts4t||t|j t ||j t |dSr|) rZrr\rrrrr"rrArrrEr!r!r"rA|s  zEqualityExpression._set_typecCstjSr)rr=rr!r!r"rszEqualityExpression.getOp)r$r%r&rrrArr!r!r!r"rys rc@seZdZddZdS)rmcCs||_t||dSr)ro Exceptionrerdrorr!r!r"resz#LogicalExpressionException.__init__Nr$r%r&rer!r!r!r"rmsrmc@seZdZdddZdS)rkNcCsN|r|rd||f}n&|r4d|}|r<|d|7}nd|}t|||dS)Nz-Unexpected token: '%s'. Expected token '%s'.zUnexpected token: '%s'.z rrmre)rdroZ unexpectedrrrvr!r!r"resz!UnexpectedTokenException.__init__)NNNrr!r!r!r"rksrkc@seZdZdddZdS)rNcCs|sd}t||d|dS)NzMore tokens expected.zEnd of input found. rrr!r!r"resz$ExpectedMoreTokensException.__init__)Nrr!r!r!r"rsrcCs&t|tstd|td|dk S)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 rz ^[a-df-z]\d*$NrZrr\rrr:r!r!r"rsrcCs&t|tstd|td|dk S)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 rz ^[A-Z]\d*$Nrrr!r!r"rsrcCs&t|tstd|td|dk S)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 rz^e\d*$Nrrr!r!r"rsrcCsHtj}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||td}t|t||kdS)Nz3====================Test reader====================Zjohnzman(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)r)r'rrFr7rIr)Zlexpre1e2r!r!r"demos8               rcCsttdtdtdtdtdtdtdtdtd 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)rF demoExceptionr!r!r!r" demo_errorssrc CsLzt|Wn8tk rF}zt|jjd|W5d}~XYnXdS)Nr)r'rrmrFrr$)rrur!r!r"rsrcCst|d|jdS)Nz : )rFrr )exr!r!r" printtype sr__main__)NN)NN)N)N)KrrPr collectionsr functoolsrrZnltk.internalsrZ nltk.utilrrrrrJrKrNrOrrrrrrr r r rrrrrrrrrrrr"rpr#r'rrVrUrr\rrrrrrrrrrrwrrrrrrmrkrrrrrrrrr$r!r!r!r" s   -   o    5!  KK'],0      !