U eRC@sddlmZddlmZmZeZGdddZGdddeZGdddZGd d d eZ Gd d d e Z Gd dde Z GdddeZ GdddeZ GdddZGdddeZGdddeZGdddeZddZedkredS))Counter)APP LogicParserc@s*eZdZdZdZdZeegZeegZdS)Tokens()z-oN)__name__ __module__ __qualname__OPENCLOSEIMPZPUNCTTOKENSrrU/var/www/html/assets/scripts/venv/lib/python3.8/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 Zoperator_precedenceZright_associated_operationsselfrrrrs zLinearLogicParser.__init__cCstjSN)rrrrrrget_all_symbols$sz!LinearLogicParser.get_all_symbolscCs0|tjkr|||S|tjkr,|||SdSr)rrZhandle_variabler handle_open)rtokcontextrrrhandle's   zLinearLogicParser.handlecCs|tjkrtSdSdSr)rr ImpExpression)rrrrrget_BooleanExpression_factory-s z/LinearLogicParser.get_BooleanExpression_factorycCs |||Srr)rfactoryfirstsecondrrrmake_BooleanExpression3sz(LinearLogicParser.make_BooleanExpressioncCsT|t|rP|drP|dtjkrP||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 |drt|St|SdS)Nr)isupperVariableExpressionConstantExpression)rnamerrrmake_VariableExpressionCs z)LinearLogicParser.make_VariableExpressionN) rr r __doc__rrrrr#r'r,rrrrrs rc@s8eZdZeZeddZd ddZddZdd Z dS) ExpressioncCs |j|Sr)_linear_logic_parserparse)clssrrr fromstringNszExpression.fromstringNcCs t|||Sr)r%)rotherZ other_indicesrrrapplytoRszExpression.applytocCs ||Sr)r5rr4rrr__call__UszExpression.__call__cCsd|jjd|dS)N< >) __class__rrrrr__repr__XszExpression.__repr__)N) rr r rr/ classmethodr3r5r7r<rrrrr.Js   r.c@sXeZdZdddZdddZddZdd Zd d Zd d ZddZ ddZ ddZ dS)AtomicExpressionNcCs&t|tst||_|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) isinstancestrAssertionErrorr+ dependencies)rr+rBrrrr]s zAtomicExpression.__init__cCs|r||kr||S|SdS)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`` Nrrbindingsrrrsimplifyis zAtomicExpression.simplifycCsg|_|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 rBr index_counterglueFormulaFactoryrrr compile_posvszAtomicExpression.compile_poscCsg|_|gfSrFrGrHrrr compile_negszAtomicExpression.compile_negcCs||j|_dSr)Zinitialize_labelr+lowerrZfstructrrrinitialize_labelssz"AtomicExpression.initialize_labelscCs|j|jko|j|jkSr)r;r+r6rrr__eq__szAtomicExpression.__eq__cCs ||k Srrr6rrr__ne__szAtomicExpression.__ne__cCs|j}|jr|d|j7}|SNz%s)r+rB)raccumrrr__str__szAtomicExpression.__str__cCs t|jSr)hashr+rrrr__hash__szAtomicExpression.__hash__)N)N) rr r rrErKrLrOrPrQrTrVrrrrr>\s   r>c@seZdZddZdS)r*cCs`t|tstt|trDz|t||fgWStk r@YqPXn ||krP|St|||dS)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' N)r?r.rAr) BindingDictVariableBindingExceptionUnificationException)rr4rDrrrunifys  zConstantExpression.unifyNrr r rZrrrrr*sr*c@seZdZddZdS)r)c Csjt|tstz&||kr|WS|t||fgWSWn0tk rd}zt||||W5d}~XYnXdS)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)r?r.rArWrXrYrr4rDerrrrZs zVariableExpression.unifyNr[rrrrr)sr)c@s^eZdZddZdddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ dS)rcCs,t|tstt|tst||_||_dS)z :param antecedent: ``Expression`` for the antecedent :param consequent: ``Expression`` for the consequent N)r?r.rA antecedent consequent)rr^r_rrrrszImpExpression.__init__NcCs||j||j|Sr)r;r^rEr_rCrrrrEs zImpExpression.simplifyc Csjt|tstz&||j|j||j|j|WStk rd}zt||||W5d}~XYnXdS)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)r?rrAr^rZr_rXrYr\rrrrZs zImpExpression.unifycCs6|j||\}}|j||\}}t||||fSrF)r^rLr_rKr)rrIrJaa_newcc_newrrrrKszImpExpression.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)r^rKr_rLgetrBappend) rrIrJr`rarbrcZ fresh_indexnew_vrrrrLs  zImpExpression.compile_negcCs|j||j|dSr)r^rOr_rNrrrrOs zImpExpression.initialize_labelscCs$|j|jko"|j|jko"|j|jkSr)r;r^r_r6rrrrP s    zImpExpression.__eq__cCs ||k Srrr6rrrrQszImpExpression.__ne__cCsdtj|jtj|jtjS)Nz {}{} {} {}{})formatrr r^r r_r rrrrrTszImpExpression.__str__cCs"tt|jtjt|jSr)rUr^rr r_rrrrrVszImpExpression.__hash__)N) rr r rrErZrKrLrOrPrQrTrVrrrrrs   rc@s@eZdZdddZdddZddZdd Zd d Zd d ZdS)r%Nc Cs |}|}t|tstt|ts,tt}z>t|trH||j7}t|tr\||j7}||j ||7}Wn>t k r}z t d|d|d||W5d}~XYnX|rt |jj |kst d||ft |jj |krt 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)rEr?rrAr.rWr%rDr^rZrYLinearLogicApplicationExceptionsetrBfunctionr&)rrjr&Zargument_indicesZ function_simpZ argument_simprDr]rrrr#sB    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`` )rDrjrEr_rCrrrrEOs zApplicationExpression.simplifycCs$|j|jko"|j|jko"|j|jkSr)r;rjr&r6rrrrP]s    zApplicationExpression.__eq__cCs ||k Srrr6rrrrQdszApplicationExpression.__ne__cCs d|jtjd|jtjSrR)rjrr r&r rrrrrTgszApplicationExpression.__str__cCs"tt|jtjt|jSr)rUr^rr r_rrrrrVjszApplicationExpression.__hash__)N)N) rr r rrErPrQrTrVrrrrr%"s  , r%c@sVeZdZdddZddZddZdd Zd d Zd d ZddZ ddZ ddZ dS)rWNcCs6i|_t|tr|}|r2|D]\}}|||<q dS)z :param bindings: list [(``VariableExpression``, ``AtomicExpression``)] to initialize the dictionary dict {``VariableExpression``: ``AtomicExpression``} to initialize the dictionary N)dr?dictitems)rrDvbrrrros   zBindingDict.__init__cCs^t|tstt|tst||ks(t|j|d}|rB||krN||j|<n td|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: ``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)r?r)rAr.rkrdrX)rvariableZbindingexistingrrr __setitem__~s    zBindingDict.__setitem__cCsJt|tst|j|}|rFz|j|}Wqtk rB|YSXqdS)zD Return the expression to which 'variable' is bound N)r?r)rArkKeyError)rrpZ intermediaterrr __getitem__s zBindingDict.__getitem__cCs ||jkSrrk)ritemrrr __contains__szBindingDict.__contains__c Cszz@t}|jD]}|j|||<q|jD]}|j|||<q(|WStk rt}ztd||f|W5d}~XYnXdS)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)rWrkrX)rr4combinedrnr]rrr__add__s  zBindingDict.__add__cCs ||k Srrr6rrrrQszBindingDict.__ne__cCst|tst|j|jkSr)r?rW TypeErrorrkr6rrrrPs zBindingDict.__eq__cs*ddfddtjDdS)N{z, c3s"|]}|dj|VqdS)z: Nru).0rnrrr sz&BindingDict.__str__..})joinsortedrkkeysrrrrrTszBindingDict.__str__cCsd|S)NzBindingDict: %srrrrrr<szBindingDict.__repr__)N) rr r rrrrtrwryrQrPrTr<rrrrrWns  rWc@s eZdZdS)rXNrr r rrrrrXsrXc@seZdZddZdS)rYc Cs"t|d|d|d|dS)Nz Cannot unify z with z given ) Exceptionr)rr`rorDrrrrszUnificationException.__init__N)rr r rrrrrrYsrYc@s eZdZdS)rhNrrrrrrhsrhcCsztj}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)))r.r3printrE)Zlexprrrrdemos    r__main__N)Znltk.internalsrZnltk.sem.logicrr_counterrrr.r>r*r)rr%rWrrXrYrhrrrrrr s"  /CYLY