\h}SrSSKJr "SS5r"SS5r"SS5rSS jrS rS rS r Sr Sr Sr Sr Srg )aFGeneric Unification algorithm for expression trees with lists of children This implementation is a direct translation of Artificial Intelligence: A Modern Approach by Stuart Russel and Peter Norvig Second edition, section 9.2, page 276 It is modified in the following ways: 1. We allow associative and commutative Compound expressions. This results in combinatorial blowup. 2. We explore the tree lazily. 3. We provide generic interfaces to symbolic algebra libraries in Python. A more traditional version can be found here http://aima.cs.berkeley.edu/python/logic.html )kbinsc0\rSrSrSrSrSrSrSrSr g) CompoundziA little class to represent an interior node in the tree This is analogous to SymPy.Basic for non-Atoms cXlX lgN)opargs)selfr r s H/var/www/auris/envauris/lib/python3.13/site-packages/sympy/unify/core.py__init__Compound.__init__s  c[U5[U5L=(a9 URUR:H=(a URUR:H$r)typer r r others r __eq__Compound.__eq__s@T d5k)(dgg.A( UZZ' )rcX[[U5URUR45$r)hashrr r r s r __hash__Compound.__hash__"s T$Z$))455rc[UR5<SSR[[UR55<S3$)N[z, ])strr joinmapr rs r __str__Compound.__str__%s)tww<3sDII3F)GHHr)r r N __name__ __module__ __qualname____firstlineno____doc__r rrr!__static_attributes__rr rrs)6Irrc0\rSrSrSrSrSrSrSrSr g) Variable(z A Wild token cXlgrarg)r r0s r r Variable.__init__*srcn[U5[U5L=(a URUR:H$r)rr0rs r rVariable.__eq__-s'DzT%[(BTXX-BBrcB[[U5UR45$r)rrr0rs r rVariable.__hash__0sT$Z*++rc2S[UR5-$)Nz Variable(%s)rr0rs r r!Variable.__str__3sDHH --rr/Nr#r*rr r,r,(sC,.rr,c0\rSrSrSrSrSrSrSrSr g) CondVariable6zxA wild token that matches conditionally. arg - a wild token. valid - an additional constraining function on a match. cXlX lgrr0valid)r r0r>s r r CondVariable.__init__<s  rc[U5[U5L=(a9 URUR:H=(a URUR:H$r)rr0r>rs r rCondVariable.__eq__@sAT d5k)*EII%* ekk) +rcX[[U5URUR45$r)rrr0r>rs r rCondVariable.__hash__Es T$Z4::677rc2S[UR5-$)NzCondVariable(%s)r7rs r r!CondVariable.__str__Hs!CM11rr=Nr#r*rr r:r:6s + 82rr:Nc +># U=(d 0nX:XaUv g[U[[45(a[XU40UD6ShvN g[U[[45(a[XU40UD6ShvN g[U[5(Ga[U[5(GaUR SS5nUR SS5n[ URURU40UD6GHnU"U5(Ga U"U5(Ga[UR5[UR5:aX4OX4upxU"U5(a/U"U5(a"[URURS5n O![URURS5n U HxupU V s/sH"n [[ URU 55PM$ n n U V s/sH"n [[ URU 55PM$ nn [ XU40UD6ShvN Mz GM2[UR5[UR5:XdGMa[ URURU40UD6ShvN GM g[U5(av[U5(ae[U5[U5:XaL[U5S:XaUv g[ USUSU40UD6Hn[ US SUS SU40UD6ShvN M! ggggGNGNs sn fs sn fGNNN!7f) aUnify two expressions. Parameters ========== x, y - expression trees containing leaves, Compounds and Variables. s - a mapping of variables to subtrees. Returns ======= lazy sequence of mappings {Variable: subtree} Examples ======== >>> from sympy.unify.core import unify, Compound, Variable >>> expr = Compound("Add", ("x", "y")) >>> pattern = Compound("Add", ("x", Variable("a"))) >>> next(unify(expr, pattern, {})) {Variable(a): 'y'} Nis_commutativecgNFr*xs r unify..kUris_associativecgrIr*rJs r rLrMlrNr commutative associativer) isinstancer,r: unify_varrgetunifyr lenr allcombinationsunpackis_args)rKysfnsrGrOsopabcombsaaargsbbargsr0aabbsheads r rWrWKsy. RAv A,/ 0 0Q1,,,, A,/ 0 0Q1,,,, Ax Z8%<%<!1?C!1?CqttQ.#.Ca  ^A%6%6!$QVVs166{!:v!!$$):):+AFFAFFMJE+AFFAFFMJE&+NFAGH#&!$$!45BHAGH#&!$$!45BH$RS8C888',QVVAFF + <<<</  s1vQ'7 q6Q;GqtQqT144 12!"u<<<<5 (8 ) -,IH8<=szALL0L4L 5D5L*)L L)LLL5L%L4L5BL9L: L L LLLc+(# X;a[X X40UD6ShvN g[X5(ag[U[5(a%UR U5(a[ X U5v g[U[ 5(a[ X U5v ggNu7fr)rW occur_checkrTr:r>assocr,)varrKr]r^s r rUrUsy x---- S   C & &399Q<<AA C " "AA # .sBBA6Bc^TU:Xag[U[5(a[TUR5$[ U5(a[ U4SjU55(agg)z"var occurs in subtree owned by x? Tc3<># UHn[TU5v M g7fr)ri).0xirks r occur_check..s0a{3##asF)rTrrir r[any)rkrKs` r ririsJ ax Ax 3''  0a0 0 0 rc.UR5nX U'U$)z,Return copy of d with key associated to val )copy)dkeyvals r rjrjs A cF Hrc<[U5[[[4;$)zIs x a traditional iterable? )rtuplelistsetrJs r r[r[s 7udC( ((rc[U[5(a([UR5S:XaURS$U$)NrSr)rTrrXr rJs r rZrZs1!X3qvv;!#3vvayrc #b# US:XaSnUS:XaSn[U5[U5:aX4OX4up4[[[[U555[U5US9HHnXA:Xa![ SU55[ X54v M)[ X5[ SU554v MJ g7f)a Restructure A and B to have the same number of elements. Parameters ========== ordered must be either 'commutative' or 'associative'. A and B can be rearranged so that the larger of the two lists is reorganized into smaller sublists. Examples ======== >>> from sympy.unify.core import allcombinations >>> for x in allcombinations((1, 2, 3), (5, 6), 'associative'): print(x) (((1,), (2, 3)), ((5,), (6,))) (((1, 2), (3,)), ((5,), (6,))) >>> for x in allcombinations((1, 2, 3), (5, 6), 'commutative'): print(x) (((1,), (2, 3)), ((5,), (6,))) (((1, 2), (3,)), ((5,), (6,))) (((1,), (3, 2)), ((5,), (6,))) (((1, 3), (2,)), ((5,), (6,))) (((2,), (1, 3)), ((5,), (6,))) (((2, 1), (3,)), ((5,), (6,))) (((2,), (3, 1)), ((5,), (6,))) (((2, 3), (1,)), ((5,), (6,))) (((3,), (1, 2)), ((5,), (6,))) (((3, 1), (2,)), ((5,), (6,))) (((3,), (2, 1)), ((5,), (6,))) (((3, 2), (1,)), ((5,), (6,))) rQ rRN)orderedc3&# UHo4v M g7frr*)rnr`s r rp"allcombinations..s(aac3&# UHo4v M g7frr*)rnras r rprs+*CGWE 7(a(()A*<< <A$e+>> from sympy.unify.core import partition >>> partition((10, 20, 30, 40), [[0, 1, 2], [3]]) ((10, 20, 30), (40,)) )rindex)itrinds r rrs) 8t4tU2^t4 554s,cT[U5"UVs/sHo UPM sn5$s snf)zFancy indexing into an indexable iterable (tuple, list). Examples ======== >>> from sympy.unify.core import index >>> index([10, 20, 30], (1, 2, 0)) [20, 30, 10] )r)rris r rrs' 8C(CqUC( ))(s%r)r(sympy.utilities.iterablesrrr,r:rWrUrirjr[rZrYrrr*rr rs^$,II& . .22*5=n ) ,=\ 6 *r