o imA@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__OPENCLOSEIMPPUNCTTOKENSrrO/var/www/edux/Edux_v2/venv/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_precedenceright_associated_operationsselfrrrrs zLinearLogicParser.__init__cCstjSN)rrrrrrget_all_symbols$sz!LinearLogicParser.get_all_symbolscCs0|tjvr |||S|tjkr|||SdSr)rrhandle_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) has_priorityrinRangetokenrr process_next_expressionassertNextTokenr ApplicationExpression)r expressionr argumentrrrattempt_ApplicationExpression6s    z/LinearLogicParser.attempt_ApplicationExpressioncCs|dr t|St|S)Nr)isupperVariableExpressionConstantExpression)rnamerrrmake_VariableExpressionCs z)LinearLogicParser.make_VariableExpressionN) rr r __doc__rrr!r#r'r1r6rrrrrs rc@s8eZdZeZeddZd ddZddZdd Z dS) ExpressioncCs |j|Sr)_linear_logic_parserparse)clssrrr fromstringMs zExpression.fromstringNcCs t|||Sr)r.)rother other_indicesrrrapplytoQs zExpression.applytocCs ||Sr)r@rr>rrr__call__Tr(zExpression.__call__cCsd|jjd|dS)N< >) __class__rrrrr__repr__WzExpression.__repr__r) rr r rr9 classmethodr=r@rBrGrrrrr8Js   r8c@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) isinstancestrr5 dependencies)rr5rMrrrr\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 rMr index_counterglueFormulaFactoryrrr compile_posuzAtomicExpression.compile_poscCrQrRrSrTrrr compile_negrXzAtomicExpression.compile_negcCs||j|_dSr)initialize_labelr5lowerrfstructrrrinitialize_labelsrHz"AtomicExpression.initialize_labelscCs|j|jko |j|jkSr)rFr5rArrr__eq__szAtomicExpression.__eq__cC ||k SrrrArrr__ne__r(zAtomicExpression.__ne__cCs|j}|jr |d|j7}|SNz%s)r5rM)raccumrrr__str__szAtomicExpression.__str__cCs t|jSr)hashr5rrrr__hash__r(zAtomicExpression.__hash__r) rr r rrPrWrYr^r_rardrfrrrrrJ[s      rJc@eZdZddZdS)r4cCsXt|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' )rKr8r3 BindingDictVariableBindingExceptionUnificationException)rr>rOrrrunifys   zConstantExpression.unifyNrr r rkrrrrr4 r4c@rg)r3c 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)rKr8rhrirjrr>rOerrrrks zVariableExpression.unifyNrlrrrrr3rmr3c@s^eZdZddZdddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ dS)r"cCs,t|tsJt|tsJ||_||_dS)z :param antecedent: ``Expression`` for the antecedent :param consequent: ``Expression`` for the consequent N)rKr8 antecedent consequent)rrprqrrrrs zImpExpression.__init__NcCs||j||j|Sr)rFrprPrqrNrrrrPszImpExpression.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)rKr"rprkrqrirjrnrrrrks zImpExpression.unifycCs6|j||\}}|j||\}}t||||fSrR)rprYrqrWr")rrUrVaa_newcc_newrrrrWszImpExpression.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)rprWrqrYgetrMappend) rrUrVrrrsrtru fresh_indexnew_vrrrrYs  zImpExpression.compile_negcCs|j||j|dSr)rpr^rqr\rrrr^s zImpExpression.initialize_labelscC$|j|jko|j|jko|j|jkSr)rFrprqrArrrr_    zImpExpression.__eq__cCr`rrrArrrrar(zImpExpression.__ne__cCsdtj|jtj|jtjS)Nz {}{} {} {}{})formatrr rpr rqr rrrrrdszImpExpression.__str__cC"tt|jtjt|jSr)rerprr rqrrrrrf"zImpExpression.__hash__r) rr r rrPrkrWrYr^r_rardrfrrrrr"s   r"c@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)rPrKr"r8rhr.rOrprkrjLinearLogicApplicationExceptionsetrMfunctionr0)rrr0argument_indices function_simp argument_simprOrorrrr"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`` )rOrrPrqrNrrrrPNs zApplicationExpression.simplifycCrzr)rFrr0rArrrr_\r{zApplicationExpression.__eq__cCr`rrrArrrracr(zApplicationExpression.__ne__cCs d|jtjd|jtjSrb)rrr r0r rrrrrdfs zApplicationExpression.__str__cCr}r)rerprr rqrrrrrfir~zApplicationExpression.__hash__r) rr r rrPr_rardrfrrrrr.!s  , r.c@sVeZdZdddZddZddZdd Zd d Zd d ZddZ ddZ ddZ dS)rhNcCs:i|_t|tr |}|r|D] \}}|||<qdSdS)z :param bindings: list [(``VariableExpression``, ``AtomicExpression``)] to initialize the dictionary dict {``VariableExpression``: ``AtomicExpression``} to initialize the dictionary N)drKdictitems)rrOvbrrrrns   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)rKr3r8rrvri)rvariablebindingexistingrrr __setitem__}s   zBindingDict.__setitem__cCsNt|tsJ|j|}|r%z|j|}Wn ty |YSw|sdSdS)zD Return the expression to which 'variable' is bound N)rKr3rKeyError)rr intermediaterrr __getitem__s   zBindingDict.__getitem__cCs ||jvSrr)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)rhrri)rr>combinedrrorrr__add__s"  zBindingDict.__add__cCr`rrrArrrrar(zBindingDict.__ne__cCst|tst|j|jkSr)rKrh TypeErrorrrArrrr_s  zBindingDict.__eq__cs*ddfddtjDdS)N{z, c3s$|] }|dj|VqdS)z: Nr).0rrrr s"z&BindingDict.__str__..})joinsortedrkeysrrrrrds*zBindingDict.__str__cCsd|S)NzBindingDict: %srrrrrrGszBindingDict.__repr__r) rr r rrrrrrar_rdrGrrrrrhms   rhc@ eZdZdS)riNrr r rrrrriric@rg)rjc Cs"t|d|d|d|dS)Nz Cannot unify z with z given ) Exceptionr)rrrrrOrrrrr~zUnificationException.__init__N)rr r rrrrrrjrmrjc@r)rNrrrrrrrrcCsztj}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)))r8r=printrP)lexprrrrdemos    r__main__N)nltk.internalsrnltk.sem.logicrr_counterrrr8rJr4r3r"r.rhrrirjrrrrrrrs&  /CYLY