NgmAddlmZddlmZmZeZGddZGddeZGddZGd d eZ Gd d e Z Gd de Z GddeZ GddeZ GddZGddeZGddeZGddeZdZedkr edSdS))Counter)APP LogicParserc.eZdZdZdZdZeegZeegzZdS)Tokens()z-oN)__name__ __module__ __qualname__OPENCLOSEIMPPUNCTTOKENSP/var/www/html/ai-engine/env/lib/python3.11/site-packages/nltk/sem/linearlogic.pyrrs3 D E C 5ME cU]FFFrrc<eZdZdZdZdZdZdZdZdZ dZ d S) LinearLogicParserz!A linear logic expression parser.ctj|tdtjdddi|_|xjtjgz c_dS)N)r__init__rrroperator_precedenceright_associated_operationsselfs rrzLinearLogicParser.__init__sHT"""$'FJ4#C  ((VZL8((((rctjSN)rrrs rget_all_symbolsz!LinearLogicParser.get_all_symbols$s }rc|tjvr|||S|tjkr|||SdSr!)rrhandle_variabler handle_open)rtokcontexts rhandlezLinearLogicParser.handle'sP fm # #''W55 5 FK  ##C11 1 rc4|tjkrtSdSr!)rr ImpExpression)rr&s rget_BooleanExpression_factoryz/LinearLogicParser.get_BooleanExpression_factory-s &*   4rc|||Sr!r)rfactoryfirstseconds rmake_BooleanExpressionz(LinearLogicParser.make_BooleanExpression3swuf%%%rch|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_expressionassertNextTokenrApplicationExpression)r expressionr'arguments rattempt_ApplicationExpressionz/LinearLogicParser.attempt_ApplicationExpression6s   S' * * O||A O4::a==FK#?#? 77<<$$V\2222:xNN rcr|drt|St|S)Nr)isupperVariableExpressionConstantExpression)rnames rmake_VariableExpressionz)LinearLogicParser.make_VariableExpressionCs4 7??   ,%d++ +%d++ +rN) r r r __doc__rr"r(r+r0r:r@rrrrrs++999 222  &&&   ,,,,,rrcLeZdZeZedZddZdZdZ dS) Expressionc6|j|Sr!)_linear_logic_parserparse)clsss r fromstringzExpression.fromstringMs'--a000rNc$t|||Sr!)r7)rother other_indicess rapplytozExpression.applytoQs$T5-@@@rc,||Sr!)rMrrKs r__call__zExpression.__call__Ts||E"""rc(d|jjd|dS)N< >) __class__r rs r__repr__zExpression.__repr__Ws 44>*44T4444rr!) r r r rrE classmethodrIrMrPrVrrrrCrCJsr,,..11[1AAAA###55555rrCcHeZdZd dZd dZdZdZdZdZdZ d Z d Z dS) AtomicExpressionNcXt|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?r]s rrzAtomicExpression.__init__\s< $$$$$$  L(rc"|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`` rrbindingss rsimplifyzAtomicExpression.simplifyhs%  ((D> !Krcg|_|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 r]r index_counterglueFormulaFactorys r compile_poszAtomicExpression.compile_posubzrcg|_|gfSrcrdres r compile_negzAtomicExpression.compile_negrirch||j|_dSr!)initialize_labelr?lowerrfstructs rinitialize_labelsz"AtomicExpression.initialize_labelss',,TY__->->?? rcB|j|jko|j|jkSr!)rUr?rOs r__eq__zAtomicExpression.__eq__s~0LTY%*5LLrc||k Sr!rrOs r__ne__zAtomicExpression.__ne__5=  rc<|j}|jr |d|jzz }|SNz%s)r?r])raccums r__str__zAtomicExpression.__str__s+    . TD-- -E rc*t|jSr!)hashr?rs r__hash__zAtomicExpression.__hash__sDIrr!) r r r rrarhrkrqrsrurzr}rrrrYrY[s ) ) ) )          @@@MMM!!! rrYceZdZdZdS)r>ct|tsJt|tr& |t||fgzS#t$rYn wxYw||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' )r[rCr= BindingDictVariableBindingExceptionUnificationException)rrKr`s runifyzConstantExpression.unifys%,,,,, e/ 0 0  +t}o">">>>+     U]]O"4999sA AANr r r rrrrr>r>s#:::::rr>ceZdZdZdS)r=ct|tsJ ||kr|S|t||fgzS#t$r}t ||||d}~wwxYw)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[rCrrrrrKr`es rrzVariableExpression.unifys~%,,,,, Eu}}+e}o">">>>' E E E&tUH==1 D Es66 AAANrrrrr=r=s(EEEEErr=cLeZdZdZd dZdZdZdZdZdZ d Z d Z d Z dS) r*c~t|tsJt|tsJ||_||_dS)z :param antecedent: ``Expression`` for the antecedent :param consequent: ``Expression`` for the consequent N)r[rC antecedent consequent)rrrs rrzImpExpression.__init__sB *j11111*j11111$$rNc||j||j|Sr!)rUrrarr_s rrazImpExpression.simplifys=~~ O $ $X . .0H0H0R0R   rct|tsJ ||j|j|z|j|j|zS#t $r}t ||||d}~wwxYw)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[r*rrrrrrs rrzImpExpression.unifys%///// E/''(8(CCD/''(8(CCD  ( E E E&tUH==1 D EsAA A>'A99A>c|j||\}}|j||\}}t ||||zfSrc)rrkrrhr*)rrfrgaa_newcc_news rrhzImpExpression.compile_possU_00@RSS E_00@RSS Ea##UU]33rc|j||\}}|j||\}}|}|j||d|z||h}|||z|gzfS)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)rrhrrkgetr]append) rrfrgrrrr fresh_indexnew_vs rrkzImpExpression.compile_negs_00@RSS E_00@RSS E#''))  k***""5;#6K=II55=E7*++rcn|j||j|dSr!)rrqrros rrqzImpExpression.initialize_labelss4 ))'222 ))'22222rcb|j|jko|j|jko|j|jkSr!)rUrrrOs rrszImpExpression.__eq__ s7 Neo - 45#33 45#33 rc||k Sr!rrOs rruzImpExpression.__ne__rvrcdtj|jtj|jtjS)Nz {}{} {} {}{})formatrr rrrrrs rrzzImpExpression.__str__s3$$ K O J O L    rctt|jtjt|jSr!)r|rrrrrs rr}zImpExpression.__hash__s6tDO,,QfjQ$t:O:OQQRRRrr!) r r r rrarrhrkrqrsrurzr}rrrr*r*s%%%    EEE& 4 4 4 , , ,333   !!!   SSSSSrr*c6eZdZddZddZdZdZdZdZdS) r7Nc |}|}t|tsJt|tsJt } t|t r ||jz }t|t r ||jz }||j||z }n+#t$r}td|d|d||d}~wwxYw|rdt|jj |kstd|d|t|jj |krtd|d|||_ ||_||_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. NzGDependencies unfulfilled when attempting to apply Linear Logic formula zZDependencies not a proper subset of indices when attempting to apply Linear Logic formula )rar[r*rCrr7r`rrrLinearLogicApplicationExceptionsetr]functionr9)rrr9argument_indices function_simp argument_simpr`rs rrzApplicationExpression.__init__"s!))++  ))++ -77777-44444== ($9:: .H--($9:: .H--  066}hOO OHH#   1G GG=GGAGG    }/<==@PPP55$}}mm5=+899=MMM55$}}mm5 !     s&AC C+ C&&C+cR|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`` )r`rrarr_s rrazApplicationExpression.simplifyNs, %}H}%%h//::rcb|j|jko|j|jko|j|jkSr!)rUrr9rOs rrszApplicationExpression.__eq__\s5 Neo - 0 / 0 / rc||k Sr!rrOs rruzApplicationExpression.__ne__crvrc`d|jztjzd|jzztjzSrx)rrr r9rrs rrzzApplicationExpression.__str__fs)dm#fk1D4=4HH6<WWrctt|jtjt|jSr!)r|rrr rrs rr}zApplicationExpression.__hash__is6tDO,,RfkR4;P;PRRSSSrr!) r r r rrarsrurzr}rrrr7r7!s*!*!*!*!X ; ; ; ;   !!!XXXTTTTTrr7cFeZdZd dZdZdZdZdZdZdZ d Z d Z dS) rNci|_t|tr|}|r |D] \}}|||< dSdS)z :param bindings: list [(``VariableExpression``, ``AtomicExpression``)] to initialize the dictionary dict {``VariableExpression``: ``AtomicExpression``} to initialize the dictionary N)dr[dictitems)rr`vbs rrzBindingDict.__init__nsf  h % % (~~''H     1Q    rct|tsJt|tsJ||ksJ|j|d}|r||kr ||j|<dSt d|z)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=rCrrr)rvariablebindingexistings r __setitem__zBindingDict.__setitem__}s($677777':.....7""""6::h-- 7h..&DF8   *<I rct|tsJ|j|}|r% |j|}n#t$r|cYSwxYw|#dSdS)zD Return the expression to which 'variable' is bound N)r[r=rKeyError)rr intermediates r __getitem__zBindingDict.__getitem__s($677777vh'  $ $#vl3  $ $ $#### $ $ $ $ $ $s 6 AAc||jvSr!r)ritems r __contains__zBindingDict.__contains__stv~rc t}|jD]}|j|||<|jD]}|j|||<|S#t$r}td|d||d}~wwxYw)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 z;Attempting to add two contradicting VariableBindingsLists: , N)rrr)rrKcombinedrrs r__add__zBindingDict.__add__s "}}HV ( ("fQi W ) )#gaj O'   **48DD%%A  sAA A+A&&A+c||k Sr!rrOs rruzBindingDict.__ne__rvrcZt|tst|j|jkSr!)r[r TypeErrorrrOs rrszBindingDict.__eq__s(%-- Ov  rcddfdtjDzdzS)N{rc3<K|]}|dj|VdS)z: Nr).0rrs r z&BindingDict.__str__..s7RRq!22tvay22RRRRRRr})joinsortedrkeysrs`rrzzBindingDict.__str__sGTYYRRRRF46;;==r=r*r7rrrrrrr rrrrs#"""""++++++++ 799        ,,,,,,,,,, ,,,,,,^55555555"@@@@@z@@@F:::::):::,EEEEE)EEE(VSVSVSVSVSJVSVSVSrITITITITITJITITITXV(V(V(V(V(V(V(V(r     y   PPPPP9PPP      i    3 3 3 zDFFFFFr