:jN ~dZddlZddlZddlmZddlmZmZddlm Z ddl m Z dZ e Z Gdd Zd Zd Zd ZGd dZdgdZeGddZdgdZdhdZGddZGddeZGddeZGddeZGddeZGddeZGd d!eeZeZeZeZ eZ!d"Z"Gd#d$e#Z$Gd%d&e$Z%Gd'd(e$Z&Gd)d*e$Z'dhd+Z(Gd,d-Z)Gd.d/e)Z*Gd0d1e*Z+eGd2d3e*Z,Gd4d5e,Z-Gd6d7e,Z.Gd8d9e-Z/Gd:d;e,Z0d<Z1Gd=d>e*Z2Gd?d@e2Z3GdAdBe2Z4GdCdDe4Z5GdEdFe4Z6GdGdHe4Z7GdIdJe*Z8GdKdLe*Z9GdMdNe9Z:GdOdPe:Z;GdQdRe:Z<GdSdTe:Z=GdUdVe:Z>GdWdXe9Z?GdYdZe#Z@Gd[d\e@ZAGd]d^e@ZBd_ZCd`ZDdaZEdbZFdcZGddZHdeZIeJdfk(reFyy)izV A version of first order predicate logic, built on top of the typed lambda calculus. N) defaultdict)reducetotal_ordering)Counter)TrieAPPc XeZdZdZdgZdZgdZdZddgZdZ dgZ dZ dZ d Z d Zd Zgd Zd ZgdZdZddgZdZgdZdZgdZdZddgZdZdgZeezezezZeeze zZe e e egZeezezezezezezZ e Dcgc]}tCjDd|s|c}}}Z#ycc}}}w)Tokens\exists)somer existallforalliota.(),-)notr!&)andr^|or->)impliesrz=><->)iffr z<=>=z==z!=z^[-\\.(),!&^|>=<]*$N)$__name__ __module__ __qualname__LAMBDA LAMBDA_LISTEXISTS EXISTS_LISTALLALL_LISTIOTA IOTA_LISTDOTOPENCLOSECOMMANOTNOT_LISTANDAND_LISTOROR_LISTIMPIMP_LISTIFFIFF_LISTEQEQ_LISTNEQNEQ_LISTBINOPSQUANTSPUNCTTOKENSrematchSYMBOLS).0xrDs000c/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/nltk/sem/logic.pyr r s F&KF-K Cx H DI C D E E C H C H BSkG C&H C$H BDkG CvH ( *X 5F 8 #i /F $u %E g  (6 1K ?% G( RF!HHQBHH-CQ$GqHGHs ?B%B%r cgd}t|tjtjtjtj tj gD]}td|zy)z Boolean operators )negation conjunction disjunction implication equivalence%-15s %sN)zipr r2r4r6r8r:printnamespairs rI boolean_opsrVHsL UEEFJJ FIIvzz6::VW" kD !"cddg}t|tjtjgD]}t d|zy)z Equality predicates equality inequalityrPN)rQr r<r>rRrSs rIequality_predsr[Qs> &EEFIIvzz23" kD !"rWcgd}t|tjtjtjtj gD]}t d|zy)z Binding operators ) existential universallambdarPN)rQr r(r*r&r,rRrSs rI binding_opsr`ZsE 3EEFMM6::v}}fkkRS" kD !"rWceZdZdZd$dZd%dZdZdZdZdZ d%d Z d Z d Z d Z d ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ d Z!d!Z"d"Z#d#Z$y)& LogicParserz$A lambda calculus expression parser.c2t|tsJd|_g|_||_ g|_t tjDcgc]}|dfc}tjDcgc]}|dfc}ztdfgztjtjzDcgc]}|dfc}ztjDcgc]}|dfc}ztjDcgc]}|dfc}ztjDcgc]}|dfc}ztj Dcgc]}|d fc}ztj"Dcgc]}|d fc}zd gz|_tg|_y cc}wcc}wcc}wcc}wcc}wcc}wcc}wcc}w) z :param type_check: should type checking be performed to their types? :type type_check: bool r )N N) isinstancebool _currentIndex_buffer type_check quote_charsdictr r'r3rr=r?rAr5r7r9r;operator_precedenceright_associated_operations)selfrrrHs rI__init__zLogicParser.__init__fsq *d+++ $ /#'#// 0aV 0%/!1v/ 0Qxj  &~~?@!1v@ A &}}-!1v-  . &/!1v/  0 &~~.!1v.  / &/!1v/ 0 &/!1v/ 0l  $  -05( 1/@-/.//s0 E1& E6 " E;  F $ F  F & F  F Nc |j}d|_|j|\|_} |j d}|j dr(t |jdz|jd |jr|j||S#t$r8}dj||d||jdz z}td||d}~wwxYw)z Parse the expression. :param data: str for the input to be parsed :param signature: ``dict`` that maps variable names to type strings :returns: a parsed Expression rNrdz {} {} {}^ ) rstriprpprocessrqprocess_next_expressioninRangeUnexpectedTokenExceptiontokenLogicalExpressionExceptionformatindexrr typecheck)rwdata signaturemappingresultemsgs rIparsezLogicParser.parses{{} $ T 2 g ?11$7F||A.t/A/AA/EtzzRS}UU ??   Y ' * ?&&q$gaggk6J0JKC,T37Q > ?sA B C%3CCcNg}i}t|j}d}d}|}|t|kr|}|j||\} }| r |s|}|| z }2|} ||} d} | | vr<| | z } | | } t||z t| kDr||t| z} nn| | vr%>x%N "L(&2O%BXAFr'! Ut9x'#f+5XF 34A r'yyB(7GCH%JJu%E$,C! 6"CK'>W,,;C) 5) " *2T(^+EA MT"N  /GCH  JJu IC #D A C1 G|rWcd}||}|}|jD]\}}}} ||k(s| r||z }|dz }|||k7rp|||k(r5| r|||z }|dz }t||k(rtdd|z|||z }n|||z }|dz }t||k(rtdd|z|||k7rp| r|||z }|dz }|s tdd||fS||fS)Nrrdz:End of input reached. Escape character [%s] found at end.z%End of input reached. Expected: [%s]zEmpty quoted token found)rsrr) rwrrrristartendescape incl_quotess rIrz LogicParser.process_quoted_tokensE N /3/?/?  +E3 EzQJEQ1gnAw&(&!T!W,EQt9>"< $!FHN!O# a(a(FA4yA~8 "Ls"R!1gn&T!W$EQ4T;UVVax= <axrWc"tjS)z#This method exists to be overridden)r rFrws rIrzLogicParser.get_all_symbolss ~~rWcL|j|zt|jkS)z6Return TRUE if the given location is within the buffer)rprrq)rwlocations rIr~zLogicParser.inRanges!!!H,s4<"A99A>c|jdst|jdzd|jdg} |jdr3|j dt j k(r+|jdst|jdzd|j|j dsn!|j|jd|jdr2|j dt j k(r|j |j|}|r#|j|j|}|r#|S)Nrrez;Variable and Expression expected following lambda operator.r abstractedrdr) r~rrprrr r.rrr}make_LambdaExpressionpop)rwrrvarsrs rIrzLogicParser.handle_lambdaws||A-""Q&U ,,\:;<<? 1 +DLLO1&&*4J??4::a=1 KK44\B C <<?tzz!} : JJL,,S1..txxz5AE rWc|j|}|jdst|jdzd|z|j dg} |jdr3|j dt jk(r+|jdst|jdzd|j|j dsn!|j|j d|jdr2|j dt jk(r|j |j|}|r$|j||j|}|r$|S)Nrrez;Variable and Expression expected following quantifier '%s'.r quantifiedrdr) get_QuantifiedExpression_factoryr~rrprrr r.rrr}make_QuanifiedExpressionr)rwrrfactoryrrs rIrzLogicParser.handle_quants777<||A-""Q&U  ,,\:;<<? 1 +DLLO1&&*4J??4::a=1 KK44\B C <<?tzz!} : JJL,,S111'488:uME rWc|tjvrtS|tjvrtS|tj vrt S|j|tjy)z\This method serves as a hook for other logic parsers that have different quantifiersN) r r)ExistsExpressionr+ AllExpressionr-IotaExpression assertTokenrArs rIrz,LogicParser.get_QuantifiedExpression_factorysR &$$ $# # FOO # F$$ $! !   S&-- 0rWc|||Sr)rwrvariableterms rIrz$LogicParser.make_QuanifiedExpressionsx&&rWcf|jd}|jtj|Sr)r}rr r0rs rIrzLogicParser.handle_opens),,T2 V\\* rWc\|jdr|jd}|tjtjzvrf|j ||rT|j|j ||j|}|tjvr|j|}|S)zAttempt to make an equality expression. If the next token is an equality operator, then an EqualityExpression will be returned. Otherwise, the parameter will be returned.r) r~rr r=r? has_prioritymake_EqualityExpressionr}r)rwrrrs rIrz&LogicParser.attempt_EqualityExpressions <<?**Q-Cfnnv664;L;LW< !99 < )r~r __class__r#)rwrs rI__repr__zLogicParser.__repr__GsH <<? 4::a=0C"CT^^,,,t3c9C??rW)Fr)%r#r$r%__doc__rxrr|rrr~rrr}rrrrrrrrrrrrrrrrrrrrrrrrrrWrIrbrbcs.#1J64l"HA M(5$2$U-< 6< 1' "1  &!F920  RR@rWrbc`||j|}| t}g}t|jD]M\}}|j }|j ds|dk(r- |j |j|O|S#t$r}td|d||d}~wwxYw)a Convert a file of First Order Formulas into a list of {Expression}s. :param s: the contents of the file :type s: str :param logic_parser: The parser to be used to parse the logical expression :type logic_parser: LogicParser :param encoding: the encoding of the input string, if it is binary :type encoding: str :return: a list of parsed formulas. :rtype: list(Expression) N#rzUnable to parse line r) decoderb enumerate splitlinesstrip startswithrrr ValueError)s logic_parserencoding statementslinenumliners rI read_logicr"Os HHX "} J"1<<>2O zz| ??3 42:  O   l006 7 O * O4WIRvFGQ N Os) B  B-B((B-c<eZdZdZdZdZdZdZdZdZ dZ y ) rcFt|ts Jd|z||_y)z7 :param name: the name of the variable %s is not a stringN)rnstrrrs rIrxzVariable.__init__os&$$A&:T&AA$ rWcXt|txr|j|jk(Sr)rnrrrwothers rI__eq__zVariable.__eq__vs!%*FtyyEJJ/FFrWc||k( Srrr(s rI__ne__zVariable.__ne__y5=  rWc`t|tst|j|jkSr)rnr TypeErrorrr(s rI__lt__zVariable.__lt__|s$%*Oyy5::%%rWc&|j||Sr)getrwbindingss rIsubstitute_bindingszVariable.substitute_bindingss||D$''rWc,t|jSr)hashrrs rI__hash__zVariable.__hash__sDIIrWc|jSrrrs rI__str__zVariable.__str__s yyrWc d|jzS)NzVariable('%s')r:rs rIrzVariable.__repr__s$))++rWN) r#r$r%rxr*r,r0r5r8r;rrrWrIrrms+G!& (,rWrcJ|Ot|jrd}n9t|jrd}n!t|jrd}n Jdd}t |t j }|,||vr(t |t j }|||vr(|S)a Return a new, unique variable. :param pattern: ``Variable`` that is being replaced. The new variable must be the same type. :param term: a set of ``Variable`` objects that should not be returned from this function. :rtype: Variable zFe0z!Cannot generate a unique constant) is_indvarr is_funcvar is_eventvarr_counterr2)patternignoreprefixvs rIunique_variablerIs W\\ "F  %F  &F == =5F8HLLN+,-A  f x /0 1  f HrWcttdtjz}|r!t |D]}|t|}|S)zX Return a skolem function over the variables in univ_scope param univ_scope zF%s)rrrDr2r ) univ_scopeskolemrHs rIskolem_functionrMsJ  )? @ AFj! 3A.q12F 3 MrWc(eZdZdZdZedZy)Typec d|zSN%srrs rIrz Type.__repr__s d{rWctd|zSrQ)r7rs rIr8z Type.__hash__sD4K  rWct|Sr) read_type)clsrs rI fromstringzType.fromstrings |rWN)r#r$r%rr8 classmethodrWrrWrIrOrOs !rWrOcNeZdZdZdZdZejZdZdZ dZ dZ y) ComplexTypect|ts Jd|zt|ts Jd|z||_||_y)Nz%s is not a Type)rnrOrrrs rIrxzComplexType.__init__sF%&B(:U(BB&&$'D);f)DD'  rWct|txr4|j|jk(xr|j|jk(Sr)rnrZrrr(s rIr*zComplexType.__eq__s; uk * , ekk) , u||+ rWc||k( Srrr(s rIr,zComplexType.__ne__r-rWct|trL|jj|jxr%|jj|jS|t k(Sr)rnrZrmatchesrANY_TYPEr(s rIr_zComplexType.matchessH e[ )::%%ekk2Xt{{7J7J5<<7X X8# #rWc|tk(r|St|tr[|jj |j}|j j |j }|r|r t||Sy|tk(r|Syr)r`rnrZrresolver)rwr)frs rIrbzComplexType.resolvesn H K { + ""5;;/A ##ELL1AQ"1a(( X LrWc`|tk(r dtzSd|jd|jdS)NrRrrr)r`rrrs rIr;zComplexType.__str__s1 8 (? "tzzl!DKK=2 2rWc|tk(rtjSd|jjd|jjdS)Nrz -> r)r`r&rrrs rIr&zComplexType.strsC 8 <<> !tzz~~'(T[[__->,?qA ArWN) r#r$r%rxr*r,rOr8r_rbr;r&rrWrIrZrZs1  !}}H$ 3 BrWrZc<eZdZdZdZej ZdZdZy) BasicTypec<t|txr d|zd|zk(SrQ)rnrgr(s rIr*zBasicType.__eq__s!%+O$,0OOrWc||k( Srrr(s rIr,zBasicType.__ne__r-rWc"|tk(xs||k(Sr)r`r(s rIr_zBasicType.matchess 1DEM1rWc*|j|r|Syr)r_r(s rIrbzBasicType.resolves << KrWN) r#r$r%r*r,rOr8r_rbrrWrIrgrgs"P!}}H2rWrgceZdZdZdZy) EntityTypecy)Nrrrs rIr;zEntityType.__str__ rWcy)NINDrrs rIr&zEntityType.strrWNr#r$r%r;r&rrWrIrmrm s rWrmceZdZdZdZy)TruthValueTypecy)Ntrrs rIr;zTruthValueType.__str__rorWcy)NBOOLrrs rIr&zTruthValueType.strsrWNrsrrWrIrurus rWruceZdZdZdZy) EventTypecy)NrHrrs rIr;zEventType.__str__rorWcy)NEVENTrrs rIr&z EventType.strsrWNrsrrWrIr{r{s rWr{cneZdZdZedZedZdZdZe jZ dZ dZ dZ d Zy ) AnyTypecyrrrs rIrxzAnyType.__init__#s rWc|Srrrs rIrz AnyType.first& rWc|Srrrs rIrzAnyType.second*rrWcHt|txs|j|Sr)rnrr*r(s rIr*zAnyType.__eq__.s%)?U\\$-??rWc||k( Srrr(s rIr,zAnyType.__ne__1r-rWcy)NTrr(s rIr_zAnyType.matches6srWc|Srrr(s rIrbzAnyType.resolve9s rWcy)N?rrs rIr;zAnyType.__str__<rorWcy)NANYrrs rIr&z AnyType.str?rrrWN)r#r$r%rxpropertyrrr*r,rOr8r_rbr;r&rrWrIrr"sY @!}}HrWrct|tsJ|jdd}|ddk(rp|ddk(sJd}t|D]/\}}|dk(r|dz }|dk(r |dz}|dkDr!J|dk(s)|dk(s/nt t |dt ||dzdS|dd t zk(rt S|dd tzk(rtS|dd tzk(rtStdd |dz) NrzrrrrrdrrRzUnexpected character: '%s'.) rnr&replacerrZrU ENTITY_TYPE TRUTH_TYPEr`r) type_string paren_countrchars rIrUrUIs0 k3 '' '%%c2.K1~2#%%%  - GAts{q q "Q&!#  k!A& ';q1ur3J)K   Q4+- - Q4*, , Q4(? *( /+a.@  rWceZdZfdZxZS) TypeExceptionc$t||yrsuperrx)rwrrs rIrxzTypeException.__init__is rWr#r$r%rx __classcell__rs@rIrrhs rWrc eZdZdfd ZxZS)"InconsistentTypeHierarchyExceptioncF|r d|d|d}nd|z}t||y)NzThe variable 'z8' was found in multiple places with different types in ''.zDThe variable '%s' was found in multiple places with different types.r)rwrrrrs rIrxz+InconsistentTypeHierarchyException.__init__ns8 &.z;  %'  rWrrrs@rIrrms   rWrceZdZfdZxZS)TypeResolutionExceptionc Lt|d|d|jd|dy)Nz The type of 'z', 'z!', cannot be resolved with type 'r)rrxtype)rwr other_typers rIrxz TypeResolutionException.__init__}s  :??J 8 rWrrs@rIrr|   rWrceZdZfdZxZS)IllegalTypeExceptionc ft|d|jjd|d|d|d y)NzCannot set type of z 'z' to 'z'; must match type 'r)rrxrr#)rwrr allowed_typers rIrxzIllegalTypeException.__init__s+ ##,,j*l T rWrrs@rIrrrrWrcl|D]}|j|}|ddD]}|j||S)z Ensure correct typing across a collection of ``Expression`` objects. :param expressions: a collection of expressions :param signature: dict that maps variable names to types (or string representations of types) Nr)r) expressionsrrs rIrrsO"4 ((3 4"#2&( Y'( rWceZdZdZdZdZy)SubstituteBindingsIzT An interface for classes that can perform substitutions for variables. ct)z :return: The object that is obtained by replacing each variable bound by ``bindings`` with its values. Aliases are already resolved. (maybe?) :rtype: (any) NotImplementedErrorr3s rIr5z'SubstituteBindingsI.substitute_bindings "##rWct)zB :return: A list of all variables in this object. rrs rI variableszSubstituteBindingsI.variabless "##rWN)r#r$r%rr5rrrWrIrrs $$rWrceZdZdZeZedZed"dZdZ dZ dZ d Z d Z d Zd Zd ZdZdZd#dZdZdZd#dZdZedfdZd$dZd#dZdZdZdZdZdZ dZ!dZ"dZ#d Z$d!Z%y)% Expressionz >T5))rWcVt|tstd|zt||Sr)rnrr/rr(s rI__or__zExpression.__or__s*%,5=> >D%((rWcVt|tstd|zt||Sr)rnrr/rr(s rI__gt__zExpression.__gt__rrWcVt|tstd|zt||Sr)rnrr/rr(s rIr0zExpression.__lt__rrWctSr)NotImplementedr(s rIr*zExpression.__eq__srWc||k( Srrr(s rIr,zExpression.__ne__r-rWct|ts Jd|z| ddlm}|}t |j |j }|j |S)a9 Check for logical equivalence. Pass the expression (self <-> other) to the theorem prover. If the prover says it is valid, then the self and other are equal. :param other: an ``Expression`` to check equality against :param prover: a ``nltk.inference.api.Prover`` rr)Prover9)rnrnltk.inferencerrsimplifyprove)rwr)proverrbiconds rIequivzExpression.equivsV%,O.G%.OO, > .YFt}}0@A||F##rWc*tt|Sr)r7reprrs rIr8zExpression.__hash__sDJrWc*|}|jD]o}||vs||}t|tr|j|}nt|tst d||j |}|j||}q|jS)Nz>Can not substitute a non-expression value into an expression: ) rrnrrrrr5rr)rwr4exprvarvals rIr5zExpression.substitute_bindingss>># .Chsmc8,66s;C#C4$:=@ --h7||C- .}}rWcLtt}|r\|D]W}||}tt|}t |t r||_nt||_||j|Y|j||Dcic]}|||dj c}Scc}w)z Infer and check types. Raise exceptions if necessary. :param signature: dict that maps variable names to types (or string representations of types) :return: the signature, plus any additional type mappings )rr) rr rrrnrOrrUr _set_type)rwrsigkeyrvarExs rIrzExpression.typechecks$   'n*8C=9c4(!$EJ!*3EJC& ' %145#SXa[%%%555sB!ct)z Find the type of the given variable as it is used in this expression. For example, finding the type of "P" in "P(x) & Q(x,y)" yields "" :param variable: Variable rrwrs rIfindtypezExpression.findtype)rrWct)z Set the type of this expression to be the given type. Raise type exceptions where applicable. :param other_type: Type :param signature: dict(str -> list(AbstractVariableExpression)) rrwrrs rIrzExpression._set_type2s "##rWctts Jdztts Jdz|jfd|jS)au Replace every instance of 'variable' with 'expression' :param variable: ``Variable`` The variable to replace :param expression: ``Expression`` The expression with which to replace it :param replace_bound: bool Should bound variables be replaced? :param alpha_convert: bool Alpha convert automatically to avoid name clashes? %s is not a Variablerc,|jSr)r)r alpha_convertr replace_boundrs rIz$Expression.replace..Jsaii*m]SrW)rnrrvisit_structuredrrwrrrrs ````rIrzExpression.replace<s^(H-P/E/PP-*j1 % 2 1$$ S NN  rWcbfd|}tt|dD]\}}t|tr!|j t d|dzz}n3t|t r!|j t d|dzz}n|}|j|j|d}|S)z&Rename auto-generated unique variablesct|tr|hSt|tr tS|j dS)NcHttj|tSrroperatoror_setpartss rIrz>Expression.normalize..get_indiv_vars..Xs&uce2TrW)rnIndividualVariableExpressionAbstractVariableExpressionrvisit)rget_indiv_varss rIrz,Expression.normalize..get_indiv_varsQs>!9:s A9:u ww"$TrWc|jSrrrs rIrz&Expression.normalize..\s rW)rze0%srdzz%sT) rsortedrnEventVariableExpressionrrrrr)rwnewvarsrrrnewVarrs @rI normalizezExpression.normalizeNs f^D%9?STU >DAq!45XfA.>%?@A;<Xeq1uo%>?^^AJJ=F > rWct)aR Recursively visit subexpressions. Apply 'function' to each subexpression and pass the result of each function application to the 'combinator' for aggregation: return combinator(map(function, self.subexpressions)) Bound variables are neither applied upon by the function nor given to the combinator. :param function: ``Function`` to call on each subexpression :param combinator: ``Function,R>`` to combine the results of the function calls :return: result of combination ``R`` rrwr combinators rIrzExpression.visitfs "##rWc.|j|fdS)af Recursively visit subexpressions. Apply 'function' to each subexpression and pass the result of each function application to the 'combinator' for aggregation. The combinator must have the same signature as the constructor. The function is not applied to bound variables, but they are passed to the combinator. :param function: ``Function`` to call on each subexpression :param combinator: ``Function`` with the same signature as the constructor, to combine the results of the function calls :return: result of combination c|Srr)rr s rIrz-Expression.visit_structured..s *e2DrWrrs `rIrzExpression.visit_structuredwszz($DEErWc<d|jjd|dS)Nrrzr)rr#rs rIrzExpression.__repr__s"4>>**+1TF!44rWc"|jSr)r&rs rIr;zExpression.__str__sxxzrWc|j|j|jzDchc]%}tjd|j s$|'c}zScc}w)z Return a set of all the variables for binding substitution. The variables returned include all free (non-bound) individual variables and any variable starting with '?' or '@'. :return: set of ``Variable`` objects z^[?@])free predicates constantsrDrEr)rwps rIrzExpression.variablessVyy{(4>>+;; rxxQRQWQW?XA    s %A"A"c*|jddS)z Return a set of all the free (non-bound) variables. This includes both individual and predicate variables, but not constants. :return: set of ``Variable`` objects c"|jSr)rrs rIrz!Expression.free..s affhrWcHttj|tSrrrs rIrz!Expression.free..sfX\\5#%.PrWr rs rIrzExpression.frees zz  P  rWc*|jddS)zu Return a set of individual constants (non-predicates). :return: set of ``Variable`` objects c"|jSr)rrs rIrz&Expression.constants..s akkmrWcHttj|tSrrrs rIrz&Expression.constants..s6(,,su3UrWr rs rIrzExpression.constantss zz #%U  rWc*|jddS)zu Return a set of predicates (constants, not variables). :return: set of ``Variable`` objects c"|jSr)rrs rIrz'Expression.predicates..s allnrWcHttj|tSrrrs rIrz'Expression.predicates..sF8<<PSPU4VrWr rs rIrzExpression.predicatess zz $&V  rWc<|jd|jS)zD :return: beta-converted version of this expression c"|jSr)rrs rIrz%Expression.simplify..s qzz|rW)rrrs rIrzExpression.simplifys$$%;T^^LLrWct|Sr)rrs rIrz"Expression.make_VariableExpressions !(++rW)FNrFT)&r#r$r%rrbrrrXrWrrrrrrrr0r*r,rr8r5rrr`rrrrrrr;rrrrrrrrWrIrrsFMM"-">99  2' * ) * * !$$ $6.$$,t$ $0$" F5     M ,rWrceZdZdZdZdZedZedfdZ dZ dZ d Z d Z d Zd Zej"Zd ZdZedZedZdZy)ra` This class is used to represent two related types of logical expressions. The first is a Predicate Expression, such as "P(x,y)". A predicate expression is comprised of a ``FunctionVariableExpression`` or ``ConstantExpression`` as the predicate and a list of Expressions as the arguments. The second is a an application of one expression to another, such as "(\x.dog(x))(fido)". The reason Predicate Expressions are treated as Application Expressions is that the Variable Expression predicate of the expression may be replaced with another Expression, such as a LambdaExpression, which would mean that the Predicate should be thought of as being applied to the arguments. The logical expression reader will always curry arguments in a application expression. So, "\x y.see(x,y)(john,mary)" will be represented internally as "((\x y.(see(x))(y))(john))(mary)". This simplifies the internals since there will always be exactly one argument in an application. The str() method will usually print the curried forms of application expressions. The one exception is when the the application expression is really a predicate expression (ie, underlying function is an ``AbstractVariableExpression``). This means that the example from above will be returned as "(\x y.see(x,y)(john))(mary)". ct|ts Jd|zt|ts Jd|z||_||_y)z :param function: ``Expression``, for the function expression :param argument: ``Expression``, for the argument rN)rnrrrrs rIrxzApplicationExpression.__init__sH (J/U1JX1UU/(J/U1JX1UU/    rWc|jj}|jj}t|tr4|j j |j|jS|j||Sr) rrrrnrrrrrrs rIrzApplicationExpression.simplifysh==))+==))+ h 0 1==(():):HENNP P>>(H5 5rWct|jjtr |jjjSt Sr)rnrrrZrr`rs rIrzApplicationExpression.types1 dmm((+ 6==%%,, ,OrWNct|tsJ|tt}|jj t | |jj t|jj||y#t$r{}td|jd|jjd|jd|jjd|jjjd |d}~wwxYw):see Expression._set_type()NzThe function 'z' is of type 'z' and cannot be applied to 'z ' of type 'z"'. Its argument must match type 'r) rnrOrr rrr`rrZrrrr)rwrrrs rIrzApplicationExpression._set_types*d+++  #D)I )4  MM # #DMM.. ;Y ' MMMM&&MMMM&&MM&&,,   s:B D A6C??Dct|ts Jd|z|jr|j\}}n|j}|j g}|g|zDcgc]}|j |}}g}|D]:}|tk7s |r|D]}|j|s(*|j|<t|dk(rt|dStScc}w):see Expression.findtype()rrdr) rnris_atomuncurryrrrr`r_rrr ) rwrrargsargfounduniquercus rIrzApplicationExpression.findtype s(H-P/E/PP- <<>!\\^NHd}}HMM?D4<:3DECh'EE %AH}#"99Q<!"MM!$ % v;! <? "OFs Cct|jtr t}n|jj }||j j zSz:see: Expression.constants())rnrrrrr)rwfunction_constantss rIrzApplicationExpression.constants'sD dmm%? @!$ !%!8!8!: !DMM$;$;$===rWct|jtr|jjh}n|jj }||j j zSz:see: Expression.predicates())rnrrrrr)rwfunction_predss rIrz ApplicationExpression.predicates/sM dmm%7 8"mm445N!]]557N 8 8 :::rWcV|||j||jgSz:see: Expression.visit())rrrs rIrzApplicationExpression.visit7s$8DMM2HT]]4KLMMrWct|txr4|j|jk(xr|j|jk(Sr)rnrrrr(s rIr*zApplicationExpression.__eq__;s< u3 4 0 / 0 / rWc||k( Srrr(s rIr,zApplicationExpression.__ne__Br-rWcX|jr,|j\}}djd|D}n|j}d|jz}d|z}d}t |t r^t |jtr't |jjts2d}n/t |jtsd}nt |trd}|r$tj|ztjz}|tjz|ztjzS)Nrc3&K|] }d|z ywrRNr)rGr,s rI z0ApplicationExpression.__str__..Ks:ctcz:rRFT)r)r*joinrrrnrrrrBooleanExpressionr r/r0)rwrr+arg_str function_strparenthesize_functions rIr;zApplicationExpression.__str__Gs <<>!\\^NHdhh:T::G}}HT]]*Gh % h 0 1(--)>?!(--"8"8:TU,0) /@A(,% "7 8$( ! !;;5 DLfkk)G3fllBBrWc|j}|jg}t|tr9|j d|j|j}t|tr9||fS)zh Uncurry this application expression return: A tuple (base-function, arg-list) r)rrrnrinsert)rwrr+s rIr*zApplicationExpression.uncurryas\ == #89 KK8,, -((H#89$rWc(|jdS)z Return uncurried base-function. If this is an atom, then the result will be a variable expression. Otherwise, it will be a lambda expression. rr*rs rIpredzApplicationExpression.predos||~a  rWc(|jdS)z+ Return uncurried arg-list rdrGrs rIr+zApplicationExpression.argsxs ||~a  rWc6t|jtS)zk Is this expression an atom (as opposed to a lambda expression applied to a term)? )rnrHrrs rIr)zApplicationExpression.is_atoms $))%?@@rW)r#r$r%rrxrrrr`rrrrrr*r,rr8r;r*rHr+r)rrWrIrrs8!6 $,t26>;N !""HC4  !!!! ArWrcleZdZdZdZdZd dZedfdZdZ dZ d Z d Z d Z ejZd Zy)rzDThis class represents a variable to be used as a predicate or entitycFt|ts Jd|z||_y)zA :param variable: ``Variable``, for the variable rN)rnrrrs rIrxz#AbstractVariableExpression.__init__s&(H-P/E/PP-  rWc|Srrrs rIrz#AbstractVariableExpression.simplifys rWct|ts Jd|zt|ts Jd|z|j|k(r|S|S):see: Expression.replace()z%s is not an Variabler)rnrrrrs rIrz"AbstractVariableExpression.replacesU(H-Q/F/QQ-*j1 % 2 1 ==H $ KrWNctt|tsJ|tt}|}||jj D]*}|j j|}|r!t|||jj j|||jj D] }||_ yr&N) rnrOrr rrrrbrrrwrr resolutionrs rIrz$AbstractVariableExpression._set_types*d+++  #D)I t}}112 ?E++J7J8>> ? $--$$%,,T2t}}112 $E#EJ $rWcxt|ts Jd|z|j|k(r |jStSr(r)rnrrrr`rs rIrz#AbstractVariableExpression.findtypes8(H-P/E/PP- ==H $99 OrWctSr4rrs rIrz%AbstractVariableExpression.predicates u rWcXt|txr|j|jk(S)zTAllow equality between instances of ``AbstractVariableExpression`` subtypes.)rnrrr(s rIr*z!AbstractVariableExpression.__eq__s) u8 9 0 / rWc||k( Srrr(s rIr,z!AbstractVariableExpression.__ne__r-rWc`t|tst|j|jkSr)rnrr/rr(s rIr0z!AbstractVariableExpression.__lt__s%%!;<O}}u~~--rWc d|jzSrQrrs rIr;z"AbstractVariableExpression.__str__sdmm##rWr )r#r$r%rrxrrr`rrrr*r,r0rr8r;rrWrIrrsKN! $,t$" !. ""H$rWrc@eZdZdZedfdZdZeeeZdZ dZ y)rzThis class represents variables that take the form of a single lowercase character (other than 'e') followed by zero or more digits.Nct|tsJ|tt}|j t st ||t ||jjj|yrQ) rnrOrr r_rrrrrrs rIrz&IndividualVariableExpression._set_types\*d+++  #D)I!!+.&tZE E$--$$%,,T2rWctSr)rrs rI _get_typez&IndividualVariableExpression._get_typesrWc|jhSz:see: Expression.free()rrs rIrz!IndividualVariableExpression.free rWctSr1rWrs rIrz&IndividualVariableExpression.constantsrXrW) r#r$r%rr`rr`rrrrrrWrIrrs1C$,t 3 Iy )DrWrc eZdZdZeZdZdZy)rzwThis class represents variables that take the form of a single uppercase character followed by zero or more digits.c|jhSrbrrs rIrzFunctionVariableExpression.freercrWctSr1rWrs rIrz$FunctionVariableExpression.constantsrXrWN)r#r$r%rr`rrrrrWrIrrs2 DrWrceZdZdZeZy)rz{This class represents variables that take the form of a single lowercase 'e' character followed by zero or more digits.N)r#r$r%r EVENT_TYPErrrWrIrrs6 DrWrc,eZdZdZeZedfdZdZdZ y)rztThis class represents variables that do not take the form of a single character followed by zero or more digits.Nct|tsJ|tt}|tk(rt }n0|}|j t k7r|j|j }||jjD]*}|j j|}|r!t|||jjj|||jjD] }||_ yrQ) rnrOrr r`rrrbrrrrrRs rIrzConstantExpression._set_type s*d+++  #D)I  !$J#JyyK''// : t}}112 ?E++J7J8>> ? $--$$%,,T2t}}112 $E#EJ $rWctSrbrWrs rIrzConstantExpression.free%rXrWc|jhSr1rrs rIrzConstantExpression.constants)rcrW) r#r$r%rrrr`rrrrrWrIrrs"2 D#+t$0rWrc t|ts Jd|zt|jr t |St |jr t |St|jr t|St|S)z This is a factory method that instantiates and returns a subtype of ``AbstractVariableExpression`` appropriate for the given variable. r) rnrrArrrBrrCrrrs rIrr.so h )L+AH+LL )+H55 HMM ")(33 X]] #&x00!(++rWc`eZdZdZdZd dZdZdZdZdZ dZ d Z d Z e jZy ) VariableBinderExpressionzThis an abstract class for any Expression that binds a variable in an Expression. This includes LambdaExpressions and Quantified Expressionsct|ts Jd|zt|ts Jd|z||_||_y)zs :param variable: ``Variable``, for the variable :param term: ``Expression``, for the term rrN)rnrrrrrs rIrxz!VariableBinderExpression.__init__BsH (H-P/E/PP-$ +M-F-MM+   rWc *t|ts Jd|zt|ts Jd|z|j|k(rV|rRt|ts Jd|z|j |j|j j||d|S|S|rA|j|jvr%|jt|j}|j |j|j j||||S)rOrrz&%s is not a AbstractVariableExpressionT)rE) rnrrrrrrrrrrIrs rIrz VariableBinderExpression.replaceLs (H-P/E/PP-*j1 % 2 1 ==H $!*.HI>  !!(J }U rWc t|ts Jd|z|j||jj |j t |dS)zRename all occurrences of the variable introduced by this variable binder in the expression to ``newvar``. :param newvar: ``Variable``, for the new variable rT)rnrrrrrr)rwnewvars rIrz&VariableBinderExpression.alpha_convertjsS &(+L-Cf-LL+~~ DII%%dmm5G5OQUV  rWcR|jj|jhz Srb)rrrrs rIrzVariableBinderExpression.freetsyy~~4==/11rWct|ts Jd|z||jk(rtS|jj |SrU)rnrrr`rrrs rIrz!VariableBinderExpression.findtypexsC(H-P/E/PP- t}} $O99%%h/ /rWc4|||jgSr7rrs rIrzVariableBinderExpression.visit8DII./00rWcH||j||jS)z#:see: Expression.visit_structured())rrrs rIrz)VariableBinderExpression.visit_structureds$--$)))<==rWcPt||jst||jrz|j|jk(r|j|jk(St |j}|j|jj |j|k(Sy)z~Defines equality modulo alphabetic variance. If we are comparing \x.M and \y.N, then check equality of M and N[x/y].F)rnrrrrr)rwr)varexs rIr*zVariableBinderExpression.__eq__sy dEOO , 5$..0Q}}.yyEJJ..+4==9yyEJJ$6$6u~~u$MMMrWc||k( Srrr(s rIr,zVariableBinderExpression.__ne__r-rWNr )r#r$r%rrxrrrrrrr*r,rr8rrWrIrprp>sBO< 201> !""HrWrpc.eZdZedZedfdZdZy)rct|jj|j|jjSr)rZrrrrrs rIrzLambdaExpression.types*499--dmm.3Atax3r>rR)rrrrr r&r?r.rwrrs rIr;zLambdaExpression.__str__s]]O yynn.   T]] +99Dnn. MMhh333 4jj Tk  rWr#r$r%rrr`rr;rrWrIrrs' NN$,t <  rWrc.eZdZedZedfdZdZy)QuantifiedExpressionctSrrrs rIrzQuantifiedExpression.typerWNct|tsJ|tt}|j t st ||t |jjt |yrQ rnrOrr r_rrrrrs rIrzQuantifiedExpression._set_typeS*d+++  #D)I!!*-&tZD D J 2rWcn|jg}|j}|j|jk(rA|j|j|j}|j|jk(rA|j dzdj d|Dzt jzd|zzS)Nrzc3&K|] }d|z ywr<rrs rIr=z/QuantifiedExpression.__str__..rr>rR)rrrr getQuantifierr?r r.rs rIr;zQuantifiedExpression.__str__s]]O yynn.   T]] +99Dnn.     hh333 4jj Tk   rWrrrWrIrrs% $,t 3  rWrceZdZdZy)rc"tjSr)r r(rs rIrzExistsExpression.getQuantifiers }}rWNr#r$r%rrrWrIrrsrWrceZdZdZy)rc"tjSr)r r*rs rIrzAllExpression.getQuantifier zzrWNrrrWrIrrsrWrceZdZdZy)rc"tjSr)r r,rs rIrzIotaExpression.getQuantifiers {{rWNrrrWrIrrsrWrcjeZdZdZedZedfdZdZdZ dZ dZ d Z e jZd Zy) rcFt|ts Jd|z||_yr)rnrr)rwrs rIrxzNegatedExpression.__init__s$$ +M-F-MM+ rWctSrrrs rIrzNegatedExpression.typerrWNct|tsJ|tt}|j t st ||t |jjt |yrQrrs rIrzNegatedExpression._set_typerrWclt|ts Jd|z|jj|S)Nr)rnrrrrs rIrzNegatedExpression.findtypes2(H-P/E/PP-yy!!(++rWc4|||jgSr7rxrs rIrzNegatedExpression.visitryrWc|jS)z:see: Expression.negate()rxrs rIrzNegatedExpression.negates yyrWcXt|txr|j|jk(Sr)rnrrr(s rIr*zNegatedExpression.__eq__s"%!23O UZZ8OOrWc||k( Srrr(s rIr,zNegatedExpression.__ne__ r-rWcBtjd|jzzSrQ)r r2rrs rIr;zNegatedExpression.__str__szzD499,,,rW)r#r$r%rxrrr`rrrrr*r,rr8r;rrWrIrrsS$,t 3,1P!""H-rWrc^eZdZdZedZdZdZdZdZ e jZ dZ dZ y ) BinaryExpressionct|ts Jd|zt|ts Jd|z||_||_yr)rnrrrrs rIrxzBinaryExpression.__init__sF%,O.G%.OO,&*-Q/H6/QQ-  rWctSrrrs rIrzBinaryExpression.typerrWct|ts Jd|z|jj|}|jj|}||k(s |t k(r|S|t k(r|St SrU)rnrrrrr`)rwrrcrs rIrzBinaryExpression.findtypesh(H-P/E/PP- JJ   ) KK  * 6Q(]H (]HOrWcV|||j||jgSr7)rrrs rIrzBinaryExpression.visit*s$8DJJ/$++1FGHHrWct||jxst||jxr4|j|jk(xr|j|jk(Sr)rnrrrr(s rIr*zBinaryExpression.__eq__.sO eoo . S*UDNN2S , ekk) , u||+ rWc||k( Srrr(s rIr,zBinaryExpression.__ne__5r-rWc|j|j}|j|j}tj|zdz|j zdz|ztj zS)Nrz) _str_subexrrr r/getOpr0rs rIr;zBinaryExpression.__str__:sX +-{{U"S(4::<7#=FUUrWc d|zSrQr)rwsubexs rIrzBinaryExpression._str_subex?s e|rWN)r#r$r%rxrrrrr*r,rr8r;rrrWrIrrsH  I !""HV rWrceZdZedfdZy)r@Nct|tsJ|tt}|j t st ||t |jjt ||jjt |yrQ) rnrOrr r_rrrrrrs rIrzBooleanExpression._set_typeDsg*d+++  #D)I!!*-&tZD D Z3 j)4rW)r#r$r%r`rrrWrIr@r@Cs #+t 5rWr@ceZdZdZdZdZy)rz"This class represents conjunctionsc"tjSr)r r4rs rIrzAndExpression.getOpTrrWc:d|z}t|tr|ddS|SNrRrdr)rnrrwrrs rIrzAndExpression._str_subexWs% 5L e] +Qr7NrWNr#r$r%rrrrrWrIrrQs,rWrceZdZdZdZdZy)rz"This class represents disjunctionsc"tjSr)r r6rs rIrzOrExpression.getOpa yyrWc:d|z}t|tr|ddS|Sr)rnrrs rIrzOrExpression._str_subexds% 5L e\ *Qr7NrWNrrrWrIrr^s,rWrceZdZdZdZy)rz"This class represents implicationsc"tjSr)r r8rs rIrzImpExpression.getOpnrrWNr#r$r%rrrrWrIrrks ,rWrceZdZdZdZy)rz$This class represents biconditionalsc"tjSr)r r:rs rIrzIffExpression.getOpurrWNrrrWrIrrrs .rWrc"eZdZdZedfdZdZy)rz:This class represents equality expressions like "(x = y)".Nct|tsJ|tt}|j t st ||t |jjt||jjt|yrQ) rnrOrr r_rrrrrrrs rIrzEqualityExpression._set_type|sg*d+++  #D)I!!*-&tZD D [)4 k95rWc"tjSr)r r<rs rIrzEqualityExpression.getOprrW)r#r$r%rr`rrrrWrIrrysD#+t 6rWrceZdZdZy)rc>||_tj||yr)r Exceptionrxrwrrs rIrxz#LogicalExpressionException.__init__s 4)rWNr#r$r%rxrrWrIrrs*rWrceZdZddZy)rNc||r |r d|d|d}n|rd|z}|r|d|zz }nd|z}tj|||y)NzUnexpected token: 'z'. Expected token 'rzUnexpected token: '%s'.z r rrx)rwr unexpectedr rrs rIrxz!UnexpectedTokenException.__init__sP (C+j8Ctg~%(83C"++D%=rW)NNNrrrWrIrrs >rWrceZdZddZy)rNc@|sd}tj||d|zy)NzMore tokens expected.zEnd of input found. rrs rIrxz$ExpectedMoreTokensException.__init__s%-G"++ %07: rWrrrrWrIrrs rWrcft|ts Jd|ztjd|duS)z An individual variable must be a single lowercase character other than 'e', followed by zero or more digits. :param expr: str :return: bool True if expr is of the correct form r%z ^[a-df-z]\d*$Nrnr&rDrErs rIrArAs6 dC ="6"== 88$d +4 77rWcft|ts Jd|ztjd|duS)z A function variable must be a single uppercase character followed by zero or more digits. :param expr: str :return: bool True if expr is of the correct form r%z ^[A-Z]\d*$Nrrs rIrBrBs5 dC ="6"== 88M4 ( 44rWcft|ts Jd|ztjd|duS)z An event variable must be a single lowercase 'e' character followed by zero or more digits. :param expr: str :return: bool True if expr is of the correct form r%z^e\d*$Nrrs rIrCrCs5 dC ="6"== 88It $D 00rWctj}tdt|dt|dt|dt|dt|dt|dt|dt|d t|d t|d t|d t|d t|dt|dt|dtdt|djt|djt|djt|djtd|d}t||j t d}t|t||k(y)Nz3====================Test reader====================johnzman(x)z-man(x)z(man(x) & tall(x) & walks(x))z&exists x.(man(x) & tall(x) & walks(x))z \x.man(x)z\x.man(x)(john)z\x y.sees(x,y)z\x y.sees(x,y)(a,b)z(\x.exists y.walks(x,y))(x)zexists x.x = yzexists x.(x = y)zP(x) & x=y & P(y)z\P Q.exists x.(P(x) & Q(x))zman(x) <-> tall(x)z5====================Test simplify====================z\x.\y.sees(x,y)(john)(mary)z\x.\y.sees(x,y)(john, mary)z,all x.(man(x) & (\x.exists y.walks(x,y))(x))z5(\P.\Q.exists x.(P(x) & Q(x)))(\x.dog(x))(\x.bark(x))z\====================Test alpha conversion and binder expression equality====================z exists x.P(x)r>)rrWrRrrr)lexpre1e2s rIdemors  ! !E -. %. %  %  %0 12 %9 :; %  %" #$ %! "# %& '( %. /0 %! "# %# $% %# $% %. /0 %% &' /0 %. / 8 8 :; %. / 8 8 :; %? @ I I KL %H I R R TU VW  B "I  (3- (B "I "(OrWc8tdtdtdtdtdtdtdtdtd td td td td tdy)Nz:====================Test reader errors====================z (P(x) & Q(x)z((P(x) &) & Q(x))zP(x) -> zP(xzP(x,zP(x,)r z exists x.r z\ x y.zP(x)Q(x)z (P(x)Q(x)z exists x -> y)rR demoExceptionrrWrI demo_errorsrst 45.!%&*%&'(+$)*+/"rWc tj|y#t$r.}t|jj d|Yd}~yd}~wwxYw)Nr)rrWrrRrr#)rrs rIrrsF.a %. %%&b,--.s A$A  AcTt|jd|jy)Nz : )rRr&r)exs rI printtyper s RVVXJc"'' #$rW__main__)NNr)KrrrD collectionsr functoolsrrnltk.internalsr nltk.utilrrrDr rVr[r`rbr"rrIrMrOrZrgrmrur{rrrrir`rUrrrrrrrrrrrrrrrrprrrrrrrr@rrrrrrrrrArBrCrrrrr#rrWrIrs  #,"  9*I*IZ"""i@i@X<,,,@ 8   2B$2Bj&Y iB  l [ 9 >I   m  =   $$,H,$H,VGAJGATH$H$H$V#=< !; :$3$N , Z#zZ#z / < 3 >+ ( ) )- )-X-z-` 5( 5 %  $ %%),** >9 >  "<  8 5 1B#".% zFrW