/hmARSSKJr SSKJrJr \"5r"SS5r"SS\5r"SS5r"S S \5r "S S \ 5r "S S\ 5r "SS\5r "SS\5r "SS5r"SS\5r"SS\5r"SS\5rSr\S:Xa\"5 gg))Counter)APP LogicParserc4\rSrSrSrSrSr\\/r\\/-rSr g)Tokens()z-oN) __name__ __module__ __qualname____firstlineno__OPENCLOSEIMPPUNCTTOKENS__static_attributes__r L/var/www/auris/envauris/lib/python3.13/site-packages/nltk/sem/linearlogic.pyrrs' D E C 5ME cU]FrrcB\rSrSrSrSrSrSrSrSr Sr S r S r g ) LinearLogicParserz!A linear logic expression parser.c[R"U5 [S[RSSS0UlU=R [R/- slg)N)r__init__rrroperator_precedenceright_associated_operationsselfs rrLinearLogicParser.__init__s@T"$'FJJ4#C  ((VZZL8(rc"[R$N)rrr"s rget_all_symbols!LinearLogicParser.get_all_symbols$s }}rcU[R;aURX5$U[R:XaUR X5$gr&)rrhandle_variabler handle_open)r#tokcontexts rhandleLinearLogicParser.handle'sA fmm #''5 5 FKK ##C1 1 rc8U[R:Xa[$gr&)rr ImpExpression)r#r,s rget_BooleanExpression_factory/LinearLogicParser.get_BooleanExpression_factory-s &**  rcU"X#5$r&r )r#factoryfirstseconds rmake_BooleanExpression(LinearLogicParser.make_BooleanExpression3s u%%rcNUR[U5(aURS5(asURS5[R :XaPUR5 UR [5nUR[R5 [XS5nU$)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_priorityrinRangetokenrrprocess_next_expressionassertNextTokenrApplicationExpression)r# expressionr-arguments rattempt_ApplicationExpression/LinearLogicParser.attempt_ApplicationExpression6st   S' * *||A4::a=FKK#? 77<$$V\\22:N rc^USR5(a [U5$[U5$)Nr)isupperVariableExpressionConstantExpression)r#names rmake_VariableExpression)LinearLogicParser.make_VariableExpressionCs) 7??  %d+ +%d+ +r)r N) r r rr__doc__rr'r.r2r8rCrJrr rrrrs(+9 2  & ,rrcH\rSrSr\"5r\S5rSSjrSr Sr Sr g) ExpressionJc8URRU5$r&)_linear_logic_parserparse)clsss r fromstringExpression.fromstringMs''--a00rNc[XU5$r&)r@)r#other other_indicess rapplytoExpression.applytoQs$T-@@rc$URU5$r&)rZr#rXs r__call__Expression.__call__Ts||E""rc<SURRSUS3$)N< >) __class__r r"s r__repr__Expression.__repr__Ws"4>>**+1TF!44rr r&) r r rrrrQ classmethodrUrZr^rerr rrrNrNJs-,.11A#5rrNcR\rSrSrS SjrS SjrSrSrSrSr S r S r S r S r g)AtomicExpression[Nc\[U[5(deXlU(d/nX lg)zy :param name: str for the constant name :param dependencies: list of int for the indices on which this atom is dependent N) isinstancestrrI dependencies)r#rIrns rrAtomicExpression.__init__\s* $$$$$ L(rc&U(a X;aX$U$)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`` r r#bindingss rsimplifyAtomicExpression.simplifyhs (> !Krc/UlU/4$a  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 rnr# index_counterglueFormulaFactorys r compile_posAtomicExpression.compile_posubzrc/UlU/4$rvrwrxs r compile_negAtomicExpression.compile_negr}rc`URURR55Ulgr&)initialize_labelrIlowerr#fstructs rinitialize_labels"AtomicExpression.initialize_labelss,,TYY__->? rctURUR:H=(a URUR:H$r&)rdrIr]s r__eq__AtomicExpression.__eq__s'~~0LTYY%**5LLrc X:X+$r&r r]s r__ne__AtomicExpression.__ne__   rcdURnUR(aUSUR-- nU$Nz%s)rIrn)r#accums r__str__AtomicExpression.__str__s.     TD--- -E rc,[UR5$r&)hashrIr"s r__hash__AtomicExpression.__hash__sDIIr)rnrIr&)r r rrrrsr{rrrrrrrr rrriri[s1 )   @M! rric\rSrSrSrSrg)rHc[U[5(de[U[5(aU[X4/5-$X:XaU$[ XU5e![a Nf=f)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' )rlrNrG BindingDictVariableBindingExceptionUnificationException)r#rXrrs runifyConstantExpression.unifysk%,,,, e/ 0 0 +}o">>>]O"499 ,  sA AAr Nr r rrrrr rrrHrHs:rrHc\rSrSrSrSrg)rGc[U[5(deX:XaU$U[X4/5-$![an[ XU5UeSnAff=f)aX '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)rlrNrrrr#rXrres rrVariableExpression.unifys\%,,,, E}+}o">>>' E&tH=1 D Es00 A  AA r Nrr rrrGrGsErrGcT\rSrSrSrSSjrSrSrSrSr S r S r S r S r S rg)r1cx[U[5(de[U[5(deXlX lg)zk :param antecedent: ``Expression`` for the antecedent :param consequent: ``Expression`` for the consequent N)rlrN antecedent consequent)r#rrs rrImpExpression.__init__s4 *j1111*j1111$$rNcURURRU5URRU55$r&)rdrrsrrqs rrsImpExpression.simplifys6~~ OO $ $X .0H0H0R  rc[U[5(deUURRURU5-URRURU5-$![ an[ XU5UeSnAff=f)ah 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)rlr1rrrrrrs rrImpExpression.unifys%//// E//''(8(8(CD//''(8(8(CD  ( E&tH=1 D EsAA)) B3 BBcURRX5up4URRX5upV[ X55XF-4$rv)rrrr{r1)r#ryrzaa_newcc_news rr{ImpExpression.compile_possB__00S __00S a#U]33rcURRX5up4URRX5upVUR 5nUR R U5 U"SU-X715nXTU-U/-4$)a 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)rr{rrgetrnappend) r#ryrzrrrr fresh_indexnew_vs rrImpExpression.compile_negsw__00S __00S #'')  k*"5;#6=I5=E7*++rcpURRU5 URRU5 gr&)rrrrs rrImpExpression.initialize_labelss& ))'2 ))'2rcURUR:H=(a9 URUR:H=(a URUR:H$r&)rdrrr]s rrImpExpression.__eq__ sE NNeoo - 45#3#33 45#3#33 rc X:X+$r&r r]s rrImpExpression.__ne__rrcSR[RUR[RUR [R 5$)Nz {}{} {} {}{})formatrrrrrrr"s rrImpExpression.__str__s8$$ KK OO JJ OO LL   rc[[UR5[R[UR535$r&)rrrrrr"s rrImpExpression.__hash__s2tDOO,-fjj\$t:O9PQRRr)rrr&)r r rrrrsrr{rrrrrrrr rrr1r1s6% E& 4 ,3 ! Srr1c@\rSrSrS SjrS SjrSrSrSrSr S r g) r@i!Nc UR5nUR5n[U[5(de[U[5(de[ 5n[U[ 5(aXaR - n[U[ 5(aXbR - nXdRRXV5- nU(al[URR5U:d[SU<SU<35e[URR5U:Xa[SU<SU<35eXl X lX`lg![an[SUSUSU35UeSnAff=f)a1 :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 )rsrlr1rNrr@rrrrrLinearLogicApplicationExceptionsetrnfunctionrB)r#rrBargument_indices function_simp argument_simprrrs rrApplicationExpression.__init__"sU!))+  ))+ -7777-4444= ($9::---($9::--- 0066}O OH }//<<=@PP5$m5=++889=MM5$m5 !   +$ 1 d=/A3G  sA#E E' E""E'crU(d URnURRU5R$)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`` )rrrrsrrqs rrsApplicationExpression.simplifyNs+}}H}}%%h/:::rcURUR:H=(a9 URUR:H=(a URUR:H$r&)rdrrBr]s rrApplicationExpression.__eq__\sA NNeoo - 0 / 0 / rc X:X+$r&r r]s rrApplicationExpression.__ne__crrcSUR-[R-SUR--[R-$r)rrrrBrr"s rrApplicationExpression.__str__fs1dmm#fkk1D4==4HH6<<WWrc[[UR5[R[UR535$r&)rrrrrr"s rrApplicationExpression.__hash__is2tDOO,-fkk]4;P:QRSSr)rBrrrr&) r r rrrrsrrrrrr rrr@r@!s#*!X ; !XTrr@cN\rSrSrS SjrSrSrSrSrSr S r S r S r S r g)rimNc0Ul[U[5(aUR5nU(aUH up#X0U'M gg)z :param bindings: list [(``VariableExpression``, ``AtomicExpression``)] to initialize the dictionary dict {``VariableExpression``: ``AtomicExpression``} to initialize the dictionary N)drldictitems)r#rrvbs rrBindingDict.__init__ns?  h % %~~'H  Q! rc[U[5(de[U[5(deX:wdeURR US5nU(aX#:XaX RU'g[ SU-5e)ac 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)rlrGrNrrr)r#variablebindingexistings r __setitem__BindingDict.__setitem__}st($67777':...."""66::h-7.&FF8 *<I rc[U[5(deURUnU(aURUnU(aMgg![a Us$f=f)z4 Return the expression to which 'variable' is bound N)rlrGrKeyError)r#r intermediates r __getitem__BindingDict.__getitem__sZ($67777vvh'  $#vvl3 l $## $sA AAcXR;$r&r)r#items r __contains__BindingDict.__contains__svv~rc[5nURHnURUX#'M URHnURUX#'M U$![an[SU<SU<35UeSnAff=f)z :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)r#rXcombinedrrs r__add__BindingDict.__add__sz "}HVV"ffQi WW#ggaj O' *48%A  sAA A9 A44A9c X:X+$r&r r]s rrBindingDict.__ne__rrcj[U[5(d[eURUR:H$r&)rlr TypeErrorrr]s rrBindingDict.__eq__s'%--Ovv  rc^SSRU4Sj[TRR5555-S-$)N{rc3J># UHoSTRU3v M g7f)z: Nr).0rr#s r &BindingDict.__str__..s$Rrs#+ 9  ,, ,,^55"@z@F:):,E)E(VSJVSrITJITXV(V(r y P9P  i  3 zFr