o rZhmA@sddlmZddlmZmZeZGdddZGdddeZGdddZGd d d eZ Gd d d e Z Gd dde Z GdddeZ GdddeZ GdddZGdddeZGdddeZGdddeZddZedkr{edSdS))Counter)APP LogicParserc@s*eZdZdZdZdZeegZeegZdS)Tokens()z-oN)__name__ __module__ __qualname__OPENCLOSEIMPZPUNCTTOKENSrrC/var/www/auris/lib/python3.10/site-packages/nltk/sem/linearlogic.pyrs rc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)LinearLogicParserz!A linear logic expression parser.cCs4t|tdtjdddi|_|jtjg7_dS)N)r__init__rrr operator_precedenceZright_associated_operationsselfrrrrs zLinearLogicParser.__init__cCstjSN)rrrrrrget_all_symbols$sz!LinearLogicParser.get_all_symbolscCs0|tjvr |||S|tjkr|||SdSr)rrZhandle_variabler handle_open)rtokcontextrrrhandle's    zLinearLogicParser.handlecCs|tjkrtSdSr)rr ImpExpression)rrrrrget_BooleanExpression_factory-s z/LinearLogicParser.get_BooleanExpression_factorycCs |||Srr)rfactoryfirstsecondrrrmake_BooleanExpression3 z(LinearLogicParser.make_BooleanExpressioncCsT|t|r(|dr(|dtjkr(||t}|tjt ||d}|S)zAttempt to make an application expression. If the next tokens are an argument in parens, then the argument expression is a function being applied to the arguments. Otherwise, return the argument expression.rN) Z has_priorityrZinRangetokenrr Zprocess_next_expressionZassertNextTokenr ApplicationExpression)rZ expressionrargumentrrrattempt_ApplicationExpression6s    z/LinearLogicParser.attempt_ApplicationExpressioncCs|dr t|St|S)Nr)isupperVariableExpressionConstantExpression)rnamerrrmake_VariableExpressionCs z)LinearLogicParser.make_VariableExpressionN) rr r __doc__rrrr r$r)r.rrrrrs rc@s8eZdZeZeddZd ddZddZdd Z dS) ExpressioncCs |j|Sr)_linear_logic_parserparse)clssrrr fromstringMs zExpression.fromstringNcCs t|||Sr)r')rotherZ other_indicesrrrapplytoQs zExpression.applytocCs ||Sr)r7rr6rrr__call__Tr%zExpression.__call__cCsd|jjd|dS)N< >) __class__rrrrr__repr__WzExpression.__repr__r) rr r rr1 classmethodr5r7r9r>rrrrr0Js   r0c@sXeZdZdddZdddZddZdd Zd d Zd d ZddZ ddZ ddZ dS)AtomicExpressionNcCs&t|tsJ||_|sg}||_dS)z :param name: str for the constant name :param dependencies: list of int for the indices on which this atom is dependent N) isinstancestrr- dependencies)rr-rDrrrr\s  zAtomicExpression.__init__cCs|r ||vr ||S|S)z If 'self' is bound by 'bindings', return the atomic to which it is bound. Otherwise, return self. :param bindings: ``BindingDict`` A dictionary of bindings used to simplify :return: ``AtomicExpression`` rrbindingsrrrsimplifyhs zAtomicExpression.simplifycCg|_|gfSa3 From Iddo Lev's PhD Dissertation p108-109 :param index_counter: ``Counter`` for unique indices :param glueFormulaFactory: ``GlueFormula`` for creating new glue formulas :return: (``Expression``,set) for the compiled linear logic and any newly created glue formulas rDr index_counterglueFormulaFactoryrrr compile_posuzAtomicExpression.compile_poscCrHrIrJrKrrr compile_negrOzAtomicExpression.compile_negcCs||j|_dSr)Zinitialize_labelr-lowerrZfstructrrrinitialize_labelsr?z"AtomicExpression.initialize_labelscCs|j|jko |j|jkSr)r=r-r8rrr__eq__szAtomicExpression.__eq__cC ||k Srrr8rrr__ne__r%zAtomicExpression.__ne__cCs|j}|jr |d|j7}|SNz%s)r-rD)raccumrrr__str__szAtomicExpression.__str__cCs t|jSr)hashr-rrrr__hash__r%zAtomicExpression.__hash__r) rr r rrGrNrPrSrTrVrYr[rrrrrA[s      rAc@eZdZddZdS)r,cCsXt|tsJt|tr z |t||fgWStyYnw||kr&|St|||)a If 'other' is a constant, then it must be equal to 'self'. If 'other' is a variable, then it must not be bound to anything other than 'self'. :param other: ``Expression`` :param bindings: ``BindingDict`` A dictionary of all current bindings :return: ``BindingDict`` A new combined dictionary of of 'bindings' and any new binding :raise UnificationException: If 'self' and 'other' cannot be unified in the context of 'bindings' )rBr0r+ BindingDictVariableBindingExceptionUnificationException)rr6rFrrrunifys   zConstantExpression.unifyNrr r r`rrrrr, r,c@r\)r+c CsXt|tsJz||kr|WS|t||fgWSty+}zt||||d}~ww)a 'self' must not be bound to anything other than 'other'. :param other: ``Expression`` :param bindings: ``BindingDict`` A dictionary of all current bindings :return: ``BindingDict`` A new combined dictionary of of 'bindings' and the new binding :raise UnificationException: If 'self' and 'other' cannot be unified in the context of 'bindings' N)rBr0r]r^r_rr6rFerrrr`s zVariableExpression.unifyNrarrrrr+rbr+c@s^eZdZddZdddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ dS)rcCs,t|tsJt|tsJ||_||_dS)z :param antecedent: ``Expression`` for the antecedent :param consequent: ``Expression`` for the consequent N)rBr0 antecedent consequent)rrerfrrrrs zImpExpression.__init__NcCs||j||j|Sr)r=rerGrfrErrrrGszImpExpression.simplifyc Cs\t|tsJz||j|j||j|j|WSty-}zt||||d}~ww)a Both the antecedent and consequent of 'self' and 'other' must unify. :param other: ``ImpExpression`` :param bindings: ``BindingDict`` A dictionary of all current bindings :return: ``BindingDict`` A new combined dictionary of of 'bindings' and any new bindings :raise UnificationException: If 'self' and 'other' cannot be unified in the context of 'bindings' N)rBrrer`rfr^r_rcrrrr`s zImpExpression.unifycCs6|j||\}}|j||\}}t||||fSrI)rerPrfrNr)rrLrMaa_newcc_newrrrrNszImpExpression.compile_posc Cs\|j||\}}|j||\}}|}|j||d|||h}||||gfS)aG From Iddo Lev's PhD Dissertation p108-109 :param index_counter: ``Counter`` for unique indices :param glueFormulaFactory: ``GlueFormula`` for creating new glue formulas :return: (``Expression``,list of ``GlueFormula``) for the compiled linear logic and any newly created glue formulas zv%s)rerNrfrPgetrDappend) rrLrMrgrhrirjZ fresh_indexnew_vrrrrPs  zImpExpression.compile_negcCs|j||j|dSr)rerSrfrRrrrrSs zImpExpression.initialize_labelscC$|j|jko|j|jko|j|jkSr)r=rerfr8rrrrT    zImpExpression.__eq__cCrUrrr8rrrrVr%zImpExpression.__ne__cCsdtj|jtj|jtjS)Nz {}{} {} {}{})formatrr rer rfr rrrrrYszImpExpression.__str__cC"tt|jtjt|jSr)rZrerr rfrrrrr["zImpExpression.__hash__r) rr r rrGr`rNrPrSrTrVrYr[rrrrrs   rc@s@eZdZdddZdddZddZdd Zd d Zd d ZdS)r'Nc Cs|}|}t|tsJt|tsJt}zt|tr$||j7}t|tr.||j7}||j||7}Wnt yR}zt d|d|d||d}~ww|rut |jj |kset d||ft |jj |krut d||f||_ ||_||_dS)aY :param function: ``Expression`` for the function :param argument: ``Expression`` for the argument :param argument_indices: set for the indices of the glue formula from which the argument came :raise LinearLogicApplicationException: If 'function' cannot be applied to 'argument' given 'argument_indices'. z Cannot apply z to z. NzODependencies unfulfilled when attempting to apply Linear Logic formula %s to %szbDependencies not a proper subset of indices when attempting to apply Linear Logic formula %s to %s)rGrBrr0r]r'rFrer`r_LinearLogicApplicationExceptionsetrDfunctionr()rrur(Zargument_indicesZ function_simpZ argument_simprFrdrrrr"sF     zApplicationExpression.__init__cCs|s|j}|j|jS)a= Since function is an implication, return its consequent. There should be no need to check that the application is valid since the checking is done by the constructor. :param bindings: ``BindingDict`` A dictionary of bindings used to simplify :return: ``Expression`` )rFrurGrfrErrrrGNs zApplicationExpression.simplifycCrnr)r=rur(r8rrrrT\rozApplicationExpression.__eq__cCrUrrr8rrrrVcr%zApplicationExpression.__ne__cCs d|jtjd|jtjSrW)rurr r(r rrrrrYfs zApplicationExpression.__str__cCrqr)rZrerr rfrrrrr[irrzApplicationExpression.__hash__r) rr r rrGrTrVrYr[rrrrr'!s  , r'c@sVeZdZdddZddZddZdd Zd d Zd d ZddZ ddZ ddZ dS)r]NcCs:i|_t|tr |}|r|D] \}}|||<qdSdS)z :param bindings: list [(``VariableExpression``, ``AtomicExpression``)] to initialize the dictionary dict {``VariableExpression``: ``AtomicExpression``} to initialize the dictionary N)drBdictitems)rrFvbrrrrns   zBindingDict.__init__cCs\t|tsJt|tsJ||ksJ|j|d}|r!||kr(||j|<dStd|)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: ``VariableExpression`` The variable bind :param binding: ``Expression`` The expression to which 'variable' should be bound :raise VariableBindingException: If the variable cannot be bound in this dictionary Nz*Variable %s already bound to another value)rBr+r0rvrkr^)rvariableZbindingexistingrrr __setitem__}s   zBindingDict.__setitem__cCsNt|tsJ|j|}|r%z|j|}Wn ty |YSw|sdSdS)zD Return the expression to which 'variable' is bound N)rBr+rvKeyError)rr{Z intermediaterrr __getitem__s   zBindingDict.__getitem__cCs ||jvSrrv)ritemrrr __contains__r%zBindingDict.__contains__c Cslz t}|jD] }|j|||<q|jD] }|j|||<q|WSty5}z td||f|d}~ww)a :param other: ``BindingDict`` The dict with which to combine self :return: ``BindingDict`` A new dict containing all the elements of both parameters :raise VariableBindingException: If the parameter dictionaries are not consistent with each other zAAttempting to add two contradicting VariableBindingsLists: %s, %sN)r]rvr^)rr6combinedryrdrrr__add__s"  zBindingDict.__add__cCrUrrr8rrrrVr%zBindingDict.__ne__cCst|tst|j|jkSr)rBr] TypeErrorrvr8rrrrTs  zBindingDict.__eq__cs*ddfddtjDdS)N{z, c3s$|] }|dj|VqdS)z: Nr).0ryrrr s"z&BindingDict.__str__..})joinsortedrvkeysrrrrrYs*zBindingDict.__str__cCsd|S)NzBindingDict: %srrrrrr>szBindingDict.__repr__r) rr r rr}rrrrVrTrYr>rrrrr]ms   r]c@ eZdZdS)r^Nrr r rrrrr^r^c@r\)r_c Cs"t|d|d|d|dS)Nz Cannot unify z with z given ) Exceptionr)rrgrzrFrrrrrrzUnificationException.__init__N)rr r rrrrrr_rbr_c@r)rsNrrrrrrsrrscCsztj}t|dt|dt|dt|dt|dt|dt|dt|ddS) Nfz(g -o f)z((g -o G) -o G)z g -o h -o fz (g -o f)(g)z (H -o f)(g)z((g -o G) -o G)((g -o f))z(H -o H)((g -o f)))r0r5printrG)Zlexprrrrdemos    r__main__N)Znltk.internalsrZnltk.sem.logicrr_counterrrr0rAr,r+rr'r]rr^r_rsrrrrrrs&  /CYLY