\hfSrSSKJr SSKJr SSKJr SSKJr SSK J r J r SSK J r SSKrSSKrSS KJrJr SS KJr SS KJrJrJrJr SS KJrJrJrJrJrJ r SS K!J"r" SSK#J$r$J%r% SSK&J'r' SSK(J)r) SSK*J+r+J,r,J-r- SSK.J/r/J0r0 SSK1J2r2 SSK3J4r4 SSK5J6r6 SSK7J8r8J9r9J:r: SSK;JJ?r? Sr@SrASrB"SS\/5rCSrD"SS \/5rE\E"5rF"S!S"5rG\G"5rH"S#S$\5rI"S%S&\5rJS'rK"S(S)\5rL\="S*S+S,S-9S.5rM\="S/S+S0S-9"S1S2\55rN\="S3S+S4S-9S[S5j5rO"S6S7\5rPS[S8jrQ"S9S:\\ 5rR"S;S<\R\25rS"S=S>\R5rT"S?S@\R\25rU"SASB\R5rV"SCSD\P5rW"SESF\T5rX"SGSH\J5rY"SISJ\5rZSKr[SLr\SMr]SNr^SOr_SPr`SQraSRrbSSrcSTrdSUreS\SVjrfSWrgSXrhSYriSZ\i"\5/0\R\R'g)]a This module defines tensors with abstract index notation. The abstract index notation has been first formalized by Penrose. Tensor indices are formal objects, with a tensor type; there is no notion of index range, it is only possible to assign the dimension, used to trace the Kronecker delta; the dimension can be a Symbol. The Einstein summation convention is used. The covariant indices are indicated with a minus sign in front of the index. For instance the tensor ``t = p(a)*A(b,c)*q(-c)`` has the index ``c`` contracted. A tensor expression ``t`` can be called; called with its indices in sorted order it is equal to itself: in the above example ``t(a, b) == t``; one can call ``t`` with different indices; ``t(c, d) == p(c)*A(d,a)*q(-a)``. The contracted indices are dummy indices, internally they have no name, the indices being represented by a graph-like structure. Tensors are put in canonical form using ``canon_bp``, which uses the Butler-Portugal algorithm for canonicalization using the monoterm symmetries of the tensors. If there is a (anti)symmetric metric, the indices can be raised and lowered when the tensor is put in canonical form. ) annotations)Any)reduce)prod)abstractmethodABC) defaultdictN)IntegerRational Permutation)get_symmetric_group_sgsbsgs_direct_product canonicalize riemann_bsgs)BasicExprsympifyAddMulS) clear_cache)TupleDict) WildFunction)default_sort_key)SymbolsymbolsWild) CantSympify_sympify)AssocOp) SYMPY_INTS)eye)sympy_deprecation_warningSymPyDeprecationWarningignore_warnings)memoize_property deprecated)siftc[SSSSS9 g)Nz| The data attribute of TensorIndexType is deprecated. Use The replace_with_arrays() method instead. z1.4z deprecated-tensorindextype-attrsdeprecated_since_versionactive_deprecations_target stacklevelr%K/var/www/auris/envauris/lib/python3.13/site-packages/sympy/tensor/tensor.pydeprecate_datar5?s "'#Er3c[SSSSS9 g)Nzn The Tensor.fun_eval() method is deprecated. Use Tensor.substitute_indices() instead. 1.5deprecated-tensor-fun-evalr,r-r1r2r3r4deprecate_fun_evalr9J "'#?r3c[SSSSS9 g)Nzx Calling a tensor like Tensor(*indices) is deprecated. Use Tensor.substitute_indices() instead. r7r8r,r-r1r2r3r4deprecate_callr<Vr:r3c\rSrSrSrSSjr\S5r\S5r\S5r Sr \S5r \S 5r \S 5r SS jrS rS rSrSrSrSrSSjrSrSrg)_IndexStructureba This class handles the indices (free and dummy ones). It contains the algorithms to manage the dummy indices replacements and contractions of free indices under multiplications of tensor expressions, as well as stuff related to canonicalization sorting, getting the permutation of the expression and so on. It also includes tools to get the ``TensorIndex`` objects corresponding to the given index structure. cXlX lX0lX@l[ UR5S[ UR5--UlURR SS9 g)Nc US$Nrr2xs r4*_IndexStructure.__init__..rsAaDr3key)freedum index_typesindiceslen _ext_ranksort)selfrJrKrLrMcanon_bps r4__init___IndexStructure.__init__lsI & TYY!CM/9  . )r3c[R"U6upUVs/sHo3RPM nn[RXU5n[XX@5$s snf)a6 Create a new ``_IndexStructure`` object from a list of ``indices``. Explanation =========== ``indices`` ``TensorIndex`` objects, the indices. Contractions are detected upon construction. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, _IndexStructure >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> m0, m1, m2, m3 = tensor_indices('m0,m1,m2,m3', Lorentz) >>> _IndexStructure.from_indices(m0, m1, -m1, m3) _IndexStructure([(m0, 0), (m3, 3)], [(1, 2)], [Lorentz, Lorentz, Lorentz, Lorentz]) )r>_free_dum_from_indicestensor_index_type_replace_dummy_names)rMrJrKirLs r4 from_indices_IndexStructure.from_indicestsR*$::GD 4;*generate_indices_from_free_dum_index_types) componentsrJrKrL componentrMs r4from_components_free_dum(_IndexStructure.from_components_free_dumsE #I   y44 5$!LLTXcdt+??r3c[U5nUS:Xa USS4//4$S/[U5-n0n/n[U5HupVURnURnURn Xx4U;a|X7U4upU (aU (a[ SX4-5eSX+'SX%'OU (a SX+'SX%'O[ SX4-5eU (aUR X[45 MUR X45 MURU4X7U4'M [U5VVs/sHupVX%(dMXe4PM nnnUR5 X$4$s snnf)a Convert ``indices`` into ``free``, ``dum`` for single component tensor. Explanation =========== ``free`` list of tuples ``(index, pos, 0)``, where ``pos`` is the position of index in the list of indices formed by the component tensors ``dum`` list of tuples ``(pos_contr, pos_cov, 0, 0)`` Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, _IndexStructure >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> m0, m1, m2, m3 = tensor_indices('m0,m1,m2,m3', Lorentz) >>> _IndexStructure._free_dum_from_indices(m0, m1, -m1, m3) ([(m0, 0), (m3, 3)], [(1, 2)]) rTz2two equal contravariant indices in slots %d and %dFz.two equal covariant indices in slots %d and %d)rN enumeratenamerWis_up ValueErrorappendrP) rMnrJ index_dictrKrYindexrgtypcontris_contrposs r4rV&_IndexStructure._free_dum_from_indicessL0 L 6QZO$b( (vc'l" !'*HA::D))CKKE{j( *#; 7 ()]`c_g)ghh$) "'$) "'()Y\_[c)cddJJx(JJx(*/++q. #;'3+6,5W+=I+=xq  +=I yJs D:D:c URSS$)zO Get a list of indices, creating new tensor indices to complete dummy indices. N)rMrQs r4 get_indices_IndexStructure.get_indicess||Ar3cS/[U5S[U5---nUH upEXCU'M [RU5nUH-upxX'n U"U 5n [XS5X7'[XS5X8'M/ [R X0U5$)NrATF)rNr> _get_generator_for_dummy_indices TensorIndexrX) rJrKrLrMidxrqgenerate_dummy_namepos1pos2typ1indnames r4r_:_IndexStructure.generate_indices_from_free_dum_index_typess&#d)Ac#hJ./HCCL.NNtTJD$D)$/G't[TU5nTU==S- ss'URS-U-$Nrerstr dummy_namerWndcdts r4dummy_name_genH_IndexStructure._get_generator_for_dummy_indices..dummy_name_gen:S*+,B ! "a ' "$//#5: :r3)r intrgsplitrWrmax)rJindxiposrrs @r4rx0_IndexStructure._get_generator_for_dummy_indicess#JDyys#A&$*@*@*K*KK.1#d6L6L2MsSWS\S\SbSbcfSghiSjOknoOo.pD**+ ; r3c2URSS9 [U5n[U5[U5S[U5--:Xde[R U5nUH7upVX5R nU"U5n[ XS5X5'[ XS5X6'M9 U$)Nc US$rCr2rDs r4rF6_IndexStructure._replace_dummy_names..sqtr3rHrATF)rPlistrNr>rxrWry) rMrJrK new_indicesr{ipos1ipos2r~rs r4rX$_IndexStructure._replace_dummy_namess ^$7m 7|s4y1SX:5555-NNtTLE%77D)$/G!,WD!AK !,WE!BK   r3c`[URSS9nUVs/sHo"SPM sn$s snf)z Get a list of free indices. c US$Nrer2rDs r4rF2_IndexStructure.get_free_indices.. sqtr3rHrsortedrJ)rQrJrYs r4get_free_indices _IndexStructure.get_free_indicess. dii^4"#d!d###s+cdSRURURUR5$)Nz_IndexStructure({}, {}, {}))formatrJrKrLrts r4__str___IndexStructure.__str__s%,33DIItxxIYIYZZr3c"UR5$r])rrts r4__repr___IndexStructure.__repr__s||~r3cDURSSnURSS9 U$)Nc US$rCr2rDs r4rFD_IndexStructure._get_sorted_free_indices_for_canon..sqtr3rH)rJrP)rQ sorted_frees r4"_get_sorted_free_indices_for_canon2_IndexStructure._get_sorted_free_indices_for_canons&iil ^,r3c,[URSS9$)Nc US$rCr2rDs r4rFC_IndexStructure._get_sorted_dum_indices_for_canon..sadr3rH)rrKrts r4!_get_sorted_dum_indices_for_canon1_IndexStructure._get_sorted_dum_indices_for_canonsdhhN33r3cUR5SnS/UR-n[UR5Hup4XBU"U5'M U$rC)indices_canon_argsrOrfrL)rQ permutationrLrYits r4)_get_lexicographically_sorted_index_types9_IndexStructure._get_lexicographically_sorted_index_typessN--/2 fT^^+ t//0EA*, A '1r3cUR5SnS/UR-n[UR5Hup4XBU"U5'M U$rC)rrOrfrM)rQrrMrYrs r4%_get_lexicographically_sorted_indices5_IndexStructure._get_lexicographically_sorted_indices%sK--/2 &'t||,EA&(KN #-r3cUR5Vs/sHo3SPM nnUR5nUR5n[U5nURn[ X- S-5Vs/sH nS/S-PM n n/n S/U-n S/U-n [ U5HpnXn X]X'XmX'X:a.XMnXXMR :XdeU RX45 MFX- n[US5unnU(a X9US'MiX9US'Mr U Vs/sHn[U5PM n n[XX5$s snfs snfs snf)a4 Returns a ``_IndexStructure`` instance corresponding to the permutation ``g``. Explanation =========== ``g`` permutation corresponding to the tensor in the representation used in canonicalization ``is_canon_bp`` if True, then ``g`` is the permutation corresponding to the canonical form of the tensor rrANre) rrrrNrOrangerWrjdivmodtupler>)rQg is_canon_bprYrlex_index_types lex_indicesnfreerankrKrJrLrMgiindjidumcovrEs r4 perm2tensor_IndexStructure.perm2tensor,sW&*%L%L%NO%Nt%N OHHJ@@B K ~~!& q'8!9:!9Avax!9:fTk &+tAB,0KN$GJz!o"~)J)JJJJ SH%J"1aL c#$IaL#$IaL"%%AuQx%t+??7P ;(&sD2,D7D<ctSSKJn URnS/U-X"S-/-nSn[UR 55H unupgXSU'M [ UR 5n[ UR 5n /n Sn /n /n UR5HupXU'U S-X?'U S- n URUnUU :waBU (aU RU 5 XS-/n Un U RU"UR55 OU RXS-/5 US- nM U (aU RU 5 U"U5X4$)z Returns ``(g, dummies, msym, v)``, the entries of ``canonicalize`` See ``canonicalize`` in ``tensor_can.py`` in combinatorics module. r)_af_newNrecUcgURnU[RS5:XagU[RS5:Xagg)NrArre)symmetryTensorSymmetryfully_symmetric)metricsyms r4metric_symmetry_to_msymC_IndexStructure.indices_canon_args..metric_symmetry_to_msymcsB~//Cn44Q77n44R88r3rA) sympy.combinatorics.permutationsrrOrfrrNrJrrLrjrr^)rQrrkrrrYrrrqrdummiesprevamsymrrrns r4r"_IndexStructure.indices_canon_argsVs9 = NN F1HQ3x   ))P)P)RSOA|dG T$))n  N  BBDLEeH1uAH FA""5)Cd{NN1%'N 3CJJ?@#Qw( 1HCE NN1 qz7((r3)rOrKrJrLrMNFreturnzlist[TensorIndex])__name__ __module__ __qualname____firstlineno____doc__rS staticmethodrZrbrVrur_rxrXrrrrrrrrr__static_attributes__r2r3r4r>r>bs*@@2@@<<|  H H   $[ 4(@T4)r3r>c/nSnUH/nX2:XaUSS==S- ss'MUnURUS/5 M1 /nUHupVURS;a URnO*[RURUR5nURURR URR Xg45 M U$)Nrerre)rjcomm TensorManagerget_commrbase generators)r`numtyprtvhrkrs r4components_canon_argsrs F D  9 2JqMQ MD MM4) $  A 66V 66D ))!&&!&&9D !**//1::#8#8!BC  Hr3c\rSrSr%Sr0rS\S'0rS\S'SrSr \ S5r S r S r S rS rS rSrSrSr\ S5r\ S5r\ S5r\ SSj5r\ S5r\ S5r\ S5rSrg)_TensorDataLazyEvaluatoria EXPERIMENTAL: do not rely on this class, it may change without deprecation warnings in future versions of SymPy. Explanation =========== This object contains the logic to associate components data to a tensor expression. Components data are set via the ``.data`` property of tensor expressions, is stored inside this class as a mapping between the tensor expression and the ``ndarray``. Computations are executed lazily: whereas the tensor expressions can have contractions, tensor products, and additions, components data are not computed until they are accessed by reading the ``.data`` property associated to the tensor expression. zdict[Any, Any]_substitutions_dict_substitutions_dict_tensmulcURU5nUcgSSKJn [X#5(dU$UR 5S:XaUS$UR 5S:Xa[ U5S:XaUS$U$)Nre) NDimArrayrr2)_getarrayr isinstancerrN)rQrIdatrs r4 __getitem__$_TensorDataLazyEvaluator.__getitem__seiin ;$#))J 88:?r7N XXZ1_SQq6M r3c xXR;aURU$[U[5(ag[U[5(a[ UR 5Vs/sHo"R PM sn5nUR4U-nX@R;aURU$URU5/nURXQRUR5$[U[5(GaURn[U5S:Xa[USR 5S:Xaj[ USR 5Vs/sHo"R PM sn5nUSR S4U-nX@R;aURU$UVs/sHLn[U["5(dM[U[5(aURU5O UR$PMN nn['UVs/sHn[U["5(aMUPM sn5n[)SU55(ag[+SU55(a [-S5eURXqRUR5n X-$[U[.5(Gaw/n/n URHn [U ["5(aKUR1U R$5 U R1U R2V s/sHoSPM sn 5 McUR1U 5 U R1/5 M [)SU55(ag[+SU55(a [-S5e/n SS KJn [9Xz5Hunn[U5S :aU R1U5 M([;U5V Vs0sH un nUU _M nn nUR<V s/sHn UU PM nn U R1U"UU55 M [?S U 5$gs snfs snfs snfs snfs sn fs snn fs sn f) a Retrieve ``data`` associated with ``key``. Explanation =========== This algorithm looks into ``self._substitutions_dict`` for all ``TensorHead`` in the ``TensExpr`` (or just ``TensorHead`` if key is a TensorHead instance). It reconstructs the components data that the tensor expression should have by performing on components data the operations that correspond to the abstract tensor operations applied. Metric tensor is handled in a different manner: it is pre-computed in ``self._substitutions_dict_tensmul``. Nrerc3(# UHoSLv M g7fr]r2.0rYs r4 0_TensorDataLazyEvaluator._get..0i9ic3(# UHoSLv M g7fr]r2rs r4rr r r zSMixing tensors with associated components data with tensors without components datac3(# UHoSLv M g7fr]r2rs r4rr r r c3(# UHoSLv M g7fr]r2rs r4rr r r  permutedimsrAc X-$r]r2)rEys r4rF/_TensorDataLazyEvaluator._get..sqsr3) rr TensorHeadTensorrrurhrardata_from_tensordata_contract_dumrKext_rankTensMulargsrNr`TensExprdatarallanyriTensAddrjrJrrziprf free_argsr)rQrIrY signaturesrch array_list tensmul_args data_listcoeff data_resultfree_args_listargrEsum_listrrr!r free_args_posaxess r4r_TensorDataLazyEvaluator._gets ** *++C0 0 c: & & c6 " "0AB0A1ww0ABCIMM#i/D77777==//45J))*ggs||L L c7 # #88L< A%#l1o.H.H*IQ*N"LO4O4O4Q"R4Qq774Q"RS $Q22157)C;;;;;DAA`lI`l[\pz{|GqHVZ65J5J..q1PQPVPVV`lII\Q\Ax9P!\QRE0i0000i000 "MNN00GGS\\RK$ $ c7 # #INxxc8,,$$SXX."))*BAQ4*BC$$S)"))"-  0i0000i000 "MNNH *#&y#Aiy>A%OOD)6? 6J$K6JdaQT6JM$K:=--H-3M#.-DHOOKd$;< $B*H5 5oC#S IQ+C %LHs6!P PP";6P"<P'P'<P, <P1P7cZSSKJnJnJn [ [ XP55nU"U6nU"U/UQ76$)Nre) tensorproducttensorcontractionMutableDenseNDimArray)rr0r1r2rmap) ndarray_listrKrr0r1r2arraysprodarrs r4r*_TensorDataLazyEvaluator.data_contract_dums2RRc/>?( /3//r3cxUcgURUUR5URURS5$)z This method is used when assigning components data to a ``TensMul`` object, it converts components data to a fully contravariant ndarray, which is then stored according to the ``TensorHead`` key. NT)_correct_signature_from_indicesrurJrK)rQrtensmul tensorheads r4data_tensorhead_from_tensmul5_TensorDataLazyEvaluator.data_tensorhead_from_tensmuls? <33     ! LL KK   r3cURnURcgURURUR5URUR 5$)z This method corrects the components data to the right signature (covariant/contravariant) using the metric associated with each ``TensorIndexType``. N)rarr9rurJrK)rQtensorr;s r4r)_TensorDataLazyEvaluator.data_from_tensor.sP %% ?? "33 OO    KK JJ  r3c[U[5(a [S5e[UR5S:wa [S5eURSnUR X!U5nX44$)Nzcannot assign data to TensAddrez6cannot assign data to TensMul with multiple componentsr)rrrirNr`r<)rQrIrr;newdatas r4_assign_data_to_tensor_expr4_TensorDataLazyEvaluator._assign_data_to_tensor_expr?sa c7 # #<= = s~~ ! #UV V^^A& 33DzJ""r3c SSKJn SSKJn [ U[ 5(a#UR nURRnO[ U[5(a0UR nURSRRnOK[ U[5(a6URR nURRRnWHnU"W5U:XaSOSnUn Un [[U[U555n [UR!5S- 5H3n U"X5n [#U"XU -- 55(a [%S5eU n M5 M g)Nrer)Flattenrrz'Component data symmetry structure error)rr array.arrayoprFrrrrrrr`TensorIndexTyperrr3rorderrri) rQtensrrrFrrgener sign_change data_swapped last_data permute_axesrYs r4_check_permutations_on_data4_TensorDataLazyEvaluator._check_permutations_on_dataIs&* dJ ' '99D11J f % %99D+44??J o . .;;##D--88J  E!&t!4"2KLIE5; 78L5;;=?+*<F wy|+CCDEE$%NOO( , r3c[RU5nURX5 [U[[ 45(dUR X5up[U[5(a[URUR5HcupEURc[SRU55eURR(dMIXER:wdMZ[S5e X0RU'g)a Set the components data of a tensor object/expression. Explanation =========== Components data are transformed to the all-contravariant form and stored with the corresponding ``TensorHead`` object. If a ``TensorHead`` object cannot be uniquely identified, it will raise an error. NzMindex type {} has no components data associated (needed to raise/lower index)zwrong dimension of ndarray)r parse_datarPrrrHrCr shaperLrrirdim is_numberr)rQrIvaluerrU indextypes r4 __setitem__$_TensorDataLazyEvaluator.__setitem__hs(2259 ((3 # O<==88CIC c: & &"%djj#//"B>>)$&@@Fy@QSS }}..--'$%ABB#C)-  %r3cURU gr]rrQrIs r4 __delitem__$_TensorDataLazyEvaluator.__delitem__s  $ $S )r3cXR;$r]r\r]s r4 __contains__%_TensorDataLazyEvaluator.__contains__s....r3cX RUSS4'URU5nX0RUSS4'UR5nUR5nXE-URUSS4'XT-URUSS4'g)a Assign data to the ``metric`` tensor. The metric tensor behaves in an anomalous way when raising and lowering indices. Explanation =========== A fully covariant metric is the inverse transpose of the fully contravariant metric (it is meant matrix inverse). If the metric is symmetric, the transpose is not necessary and mixed covariant/contravariant metrics are Kronecker deltas. TFN)rinverse_transpose_matrixtomatrix)rQrrinverse_transposeminvts r4add_metric_data(_TensorDataLazyEvaluator.add_metric_datas"@D((t);< 99$?BS(()=> MMO ))+@A((u)<=@D(()<=r3cSSKJnJn UR5nUR5nUS:XaU"U"UU5SXR-45nU$U"U"UU5X&45nU$)Nrer0r1r)rr0r1r)rrrqr0r1mdimddims r4_flip_index_by_metric._TensorDataLazyEvaluator._flip_index_by_metricst;{{}yy{ !8$DH D % D r3chUR5R5n[RU5$r])reinvrrSndarrayrgs r4inverse_matrix'_TensorDataLazyEvaluator.inverse_matrixs*     " " $'22155r3c|UR5R5Rn[R U5$r])rerrTrrSrss r4rd1_TensorDataLazyEvaluator.inverse_transpose_matrixs0     " " $ & &'22155r3cj[U5HupVUR(d3U(d,[RXRR U5nMIUR(aM\U(dMe[RU[R URR 5U5nM U$)z Utility function to correct the values inside the components data ndarray according to whether indices are covariant or contravariant. It uses the metric matrix to lower values of covariant indices. )rfrhrrorWrru)rrMrJrKinverserYrs r4r98_TensorDataLazyEvaluator._correct_signature_from_indicess!)GA::g/EEdLbLbLgLgijkZZZGG/EE,;;D[RTT5$r])rr) new_tensmul old_tensmulsr4 sorted_compoJ_TensorDataLazyEvaluator.add_rearrange_tensmul_parts..sorted_compos+;;KU Ur3)rr)rrrs`` r4add_rearrange_tensmul_parts4_TensorDataLazyEvaluator.add_rearrange_tensmul_partss  VEQN 44[Ar3cSSKJn [X5(d<[U5S:Xa%[ USS5(aU"USUS5nU$U"U5nU$)an Transform ``data`` to array. The parameter ``data`` may contain data in various formats, e.g. nested lists, SymPy ``Matrix``, and so on. Examples ======== >>> from sympy.tensor.tensor import _TensorDataLazyEvaluator >>> _TensorDataLazyEvaluator.parse_data([1, 3, -6, 12]) [1, 3, -6, 12] >>> _TensorDataLazyEvaluator.parse_data([[1, 2], [4, 7]]) [[1, 2], [4, 7]] rer2rAr__call__)rr2rrNhasattr)rr2s r4rS#_TensorDataLazyEvaluator.parse_datasY" 1$664yA~'$q':">">,T!Wd1g> -T2 r3r2Nr)rrrrrr__annotations__rrrrrr<rrCrPrYr^rarirorurdr9rrrSrr2r3r4rrs"+-,244 Qf00  "#)>->*/I<06666( SS r3rcX\rSrSrSrSrSr\S5rSr Sr Sr S r S r S rS rg )_TensorManageria Class to manage tensor properties. Notes ===== Tensors belong to tensor commutation groups; each group has a label ``comm``; there are predefined labels: ``0`` tensors commuting with any other tensor ``1`` tensors anticommuting among themselves ``2`` tensors not commuting, apart with those with ``comm=0`` Other groups can be defined using ``set_comm``; tensors in those groups commute with those with ``comm=0``; by default they do not commute with any other group. c$UR5 gr] _comm_initrts r4rS_TensorManager.__init__,s  r3cT[S5Vs/sHn0PM snUl[S5H'nSURSU'SURUS'M) SURSS'SURSS'SURSS'SSSS.UlSSSS.Ulgs snf)NrrerA)rrerA)r_comm_comm_symbols2i_comm_i2symbolrQrYs r4r_TensorManager._comm_init/s"'(+(Qb(+ qA DJJqM!  DJJqM!  1 a 1 a 1 a"#qA!"a1o,s B%cUR$r])rrts r4r_TensorManager.comm: zzr3c"XR;ar[UR5nURR05 SURUS'SURSU'X RU'XRU'U$URU$)z Get the commutation group number corresponding to ``i``. ``i`` can be a symbol or a number or a string. If ``i`` is not already defined its commutation group number is set. r)rrNrrjr)rQrYrks r4comm_symbols2i_TensorManager.comm_symbols2i>s (( (DJJA JJ  b ! DJJqM!  DJJqM! &'  #%&   "H##A&&r3c URU$)zC Returns the symbol corresponding to the commutation group number. )rrs r4 comm_i2symbol_TensorManager.comm_i2symbolQs""1%%r3cUS;a [S5e[U5n[U5nXR;ap[UR5nURR 05 SURUS'SURSU'X@RU'XR U'X R;ap[UR5nURR 05 SURSU'SURUS'X@RU'X R U'URUnURUnX0RUU'X0RUU'[5 g)a_ Set the commutation parameter ``c`` for commutation groups ``i, j``. Parameters ========== i, j : symbols representing commutation groups c : group commutation number Notes ===== ``i, j`` can be symbols, strings or numbers, apart from ``0, 1`` and ``2`` which are reserved respectively for commuting, anticommuting tensors and tensors not commuting with any other group apart with the commuting tensors. For the remaining cases, use this method to set the commutation rules; by default ``c=None``. The group commutation number ``c`` is assigned in correspondence to the group commutation symbols; it can be 0 commuting 1 anticommuting None no commutation property Examples ======== ``G`` and ``GH`` do not commute with themselves and commute with each other; A is commuting. >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead, TensorManager, TensorSymmetry >>> Lorentz = TensorIndexType('Lorentz') >>> i0,i1,i2,i3,i4 = tensor_indices('i0:5', Lorentz) >>> A = TensorHead('A', [Lorentz]) >>> G = TensorHead('G', [Lorentz], TensorSymmetry.no_symmetry(1), 'Gcomm') >>> GH = TensorHead('GH', [Lorentz], TensorSymmetry.no_symmetry(1), 'GHcomm') >>> TensorManager.set_comm('Gcomm', 'GHcomm', 0) >>> (GH(i1)*G(i0)).canon_bp() G(i0)*GH(i1) >>> (G(i1)*G(i0)).canon_bp() G(i1)*G(i0) >>> (G(i1)*A(i0)).canon_bp() A(i0)*G(i1) )rreNz+`c` can assume only the values 0, 1 or NonerN)rirrrNrrjrr)rQrYrcrkninjs r4set_comm_TensorManager.set_commWsMd L JK K AJ AJ (( (DJJA JJ  b ! DJJqM!  DJJqM! &'  #%&   " (( (DJJA JJ  b ! DJJqM!  DJJqM! &'  #%&   "  ! !! $  ! !! $ 2r 2r  r3c@UHup#nURX#U5 M g)zx Set the commutation group numbers ``c`` for symbols ``i, j``. Parameters ========== args : sequence of ``(i, j, c)`` N)r)rQrrYrrs r4 set_comms_TensorManager.set_commss GA! MM! "r3cbURURX!S:XdUS:XaS5$S5$)zj Return the commutation parameter for commutation group numbers ``i, j`` see ``_TensorManager.set_comm`` rN)rget)rQrYrs r4r_TensorManager.get_comms1 zz!}  a16ADDtDDr3c$UR5 g)z Clear the TensorManager. Nrrts r4clear_TensorManager.clears r3)rrrN)rrrrrrSrpropertyrrrrrrrrr2r3r4rrsF& .'&& Qf #Er3rcB\rSrSrSrSSjr\S5r\S5r\S5r \S5r \ S 5r \ S 5r \ S 5rS rS rSr\r\S5r\R(S5r\R*S5r\"SSSS9S5r\"SSSS9S5rSrSrg)rHia A TensorIndexType is characterized by its name and its metric. Parameters ========== name : name of the tensor type dummy_name : name of the head of dummy indices dim : dimension, it can be a symbol or an integer or ``None`` eps_dim : dimension of the epsilon tensor metric_symmetry : integer that denotes metric symmetry or ``None`` for no metric metric_name : string with the name of the metric tensor Attributes ========== ``metric`` : the metric tensor ``delta`` : ``Kronecker delta`` ``epsilon`` : the ``Levi-Civita epsilon`` tensor ``data`` : (deprecated) a property to add ``ndarray`` values, to work in a specified basis. Notes ===== The possible values of the ``metric_symmetry`` parameter are: ``1`` : metric tensor is fully symmetric ``0`` : metric tensor possesses no index symmetry ``-1`` : metric tensor is fully antisymmetric ``None``: there is no metric tensor (metric equals to ``None``) The metric is assumed to be symmetric by default. It can also be set to a custom tensor by the ``.set_metric()`` method. If there is a metric the metric is used to raise and lower indices. In the case of non-symmetric metric, the following raising and lowering conventions will be adopted: ``psi(a) = g(a, b)*psi(-b); chi(-a) = chi(b)*g(-b, -a)`` From these it is easy to find: ``g(-a, b) = delta(-a, b)`` where ``delta(-a, b) = delta(b, -a)`` is the ``Kronecker delta`` (see ``TensorIndex`` for the conventions on indices). For antisymmetric metrics there is also the following equality: ``g(a, -b) = -delta(a, -b)`` If there is no metric it is not possible to raise or lower indices; e.g. the index of the defining representation of ``SU(N)`` is 'covariant' and the conjugate representation is 'contravariant'; for ``N > 2`` they are linearly independent. ``eps_dim`` is by default equal to ``dim``, if the latter is an integer; else it can be assigned (for use in naive dimensional regularization); if ``eps_dim`` is not an integer ``epsilon`` is ``None``. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> Lorentz.metric metric(Lorentz,Lorentz) Nc rSU;aUSn[SUS3SSS9 Un[U[5(a [U5nUc[U5Sn[U[5(a [U5nUc[SUR-5nO [ U5nUcUnO [ U5n[ U5n[U[5(a [U5nS U;a@[ S SS S9 URS 5n U b!U S ;aS nO U RnU (aS nOSn[R"XX#UXV5n /U l U $)N dummy_fmtzh The dummy_fmt keyword to TensorIndexType is deprecated. Use dummy_name=z instead. r7z$deprecated-tensorindextype-dummy-fmtr.r/rdim_rz The 'metric' keyword argument to TensorIndexType is deprecated. Use the 'metric_symmetry' keyword argument or the TensorIndexType.set_metric() method instead. z!deprecated-tensorindextype-metric)TFrrerre) r%rrrrgrr&rr__new___autogenerated) clsrgrrUeps_dimmetric_symmetry metric_namekwargsrrobjs r4rTensorIndexType.__new__sV & {+I %%;'*/+Q  #J dC $>!114<<-@%$ !4h??r3cXlgr]_metric)rQr?s r4 set_metricTensorIndexType.set_metric|s r3c4URUR:$r]rgrQothers r4__lt__TensorIndexType.__lt__syy5::%%r3cUR$r]rrts r4rTensorIndexType.__str__s yyr3c|[5 [[5 [UsSSS5 $!,(df  g=fr]r5r'r&_tensor_data_substitution_dictrts r4rTensorIndexType.data% 4 51$76 5 5 - ;c[5 SSKJn [R U5nUR 5S:a [ S5eUR 5S:XaURR(a)URSnX0R:wa [ S5eURSnURXD5n[U5H upgXuXf4'M UnURupX:wa [ S5eURR(aURU:wa [ S5eU[U'[RURU5 [[ 5 UR#5n SSS5 [%SU5n [%S U5n [[ 5 [R ['U55W "X*5lSSS5 g!,(df  Ni=f!,(df  g=f) NrerrAz1data have to be of rank 1 (diagonal metric) or 2.rzDimension mismatchzNon-square matrix tensor.i1i2)r5rr2rrSrrirUrVrTzerosrfrrirr'r&get_kronecker_deltaryr$r) rQrr2nda_dimrU newndarrayrYvaldim1dim2rrrs r4rrs 1'2248 99;?PQ Q 99;! xx!!**Q-hh&$%9::**Q-C.44S>J#D/#&14 *DZZ  <89 9 88  xx4 !566/3&t,&66t{{DI 4 5,,.E6 t $ t $ 4 5":"E"Ec$i"PE"cN 6 5 6 56 5s$G$+G) G&) G7c[5 [[5 U[;a[U UR[;a[UR SSS5 g!,(df  g=fr]r5r'r&rrrts r4rrG 4 555248{{<<24;;? 6 5 5 7A A(z The TensorIndexType.get_kronecker_delta() method is deprecated. Use the TensorIndexType.delta attribute instead. r7z"deprecated-tensorindextype-methodsrcP[[S55n[SU/S-U5nU$)NrAr)rrr)rQsym2rs r4r#TensorIndexType.get_kronecker_deltas-5a894$40 r3z The TensorIndexType.get_epsilon() method is deprecated. Use the TensorIndexType.epsilon attribute instead. c[UR[[45(dg[ [ URS55n[ SU/UR-U5nU$)Nrer)r_eps_dimr#r rrr)rQrrs r4 get_epsilonTensorIndexType.get_epsilonsQ$--*g)>??4T]]AFGUTF4==$8#>r3cU[;a[U SnU"URSS45 U"URSS45 U"URSS45 U"URSS45 UR5nU[;a[U gg)z EXPERIMENTAL: do not rely on this API method. This destroys components data associated to the ``TensorIndexType``, if any, specifically: * metric tensor data * Kronecker tensor data cPU[R;a[RU ggr])rrrHs r4delete_tensmul_dataJTensorIndexType._components_data_full_destroy..delete_tensmul_datas%4PPP2NNsSQr3TFN)rrr)rQr rs r4_components_data_full_destroy-TensorIndexType._components_data_full_destroys 1 1.t4 T T[[$56T[[$67T[[%67T[[%78((* 2 2.u5 3r3r)NNNrer)rrrrrrrrgrrUrr(rrrrrrrrsetterdeleterr)rrrrr2r3r4rHrHsYCJ?C/7AF!!!! ; ;MM@@ &H88  [["Q"QH \\@@ "'#G   "'#G 6r3rHcd\rSrSrSrS Sjr\S5r\S5r\S5r Sr Sr S r S r g ) ryia Represents a tensor index Parameters ========== name : name of the index, or ``True`` if you want it to be automatically assigned tensor_index_type : ``TensorIndexType`` of the index is_up : flag for contravariant index (is_up=True by default) Attributes ========== ``name`` ``tensor_index_type`` ``is_up`` Notes ===== Tensor indices are contracted with the Einstein summation convention. An index can be in contravariant or in covariant form; in the latter case it is represented prepending a ``-`` to the index name. Adding ``-`` to a covariant (is_up=False) index makes it contravariant. Dummy indices have a name with head given by ``tensor_inde_type.dummy_name`` with underscore and a number. Similar to ``symbols`` multiple contravariant indices can be created at once using ``tensor_indices(s, typ)``, where ``s`` is a string of names. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, TensorIndex, TensorHead, tensor_indices >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> mu = TensorIndex('mu', Lorentz, is_up=False) >>> nu, rho = tensor_indices('nu, rho', Lorentz) >>> A = TensorHead('A', [Lorentz, Lorentz]) >>> A(mu, nu) A(-mu, nu) >>> A(-mu, -rho) A(mu, -rho) >>> A(mu, -mu) A(-L_0, L_0) cn[U[5(a [U5nOs[U[5(aUnO[USLaKSR[ UR 55n[U5nUR R U5 O [S5e[U5n[R"XX#5$NTz_i{} invalid name rrrrrNrrjrirrr)rrgrWrh name_symbols r4rTensorIndex.__new__(s dC  ,K f % %K T\==%6%E%E!FGD ,K  , , 3 3K @^, ,}}S/@HHr3c4URSR$rCrrts r4rgTensorIndex.name7rr3c URS$rrrts r4rWTensorIndex.tensor_index_type;rr3c URS$rrrts r4rhTensorIndex.is_up?rr3cJURnUR(dSU-nU$)Nz-%s)rgrh)rQss r4_printTensorIndex._printCs IIzz Ar3cdURUR4URUR4:$r])rWrgrs r4rTensorIndex.__lt__Is0''3((%**56 7r3cf[URURUR(+5nU$r])ryrgrWrhrQt1s r4__neg__TensorIndex.__neg__Ms( D$:$:ZZ" r3r2NT)rrrrrrrrgrWrhr!rr(rr2r3r4ryrysY0b I!! 7r3ryc[U[5(a$[USS9Vs/sHo"RPM nnO [ S5eUVs/sHn[ XA5PM nn[ U5S:XaUS$U$s snfs snf)ay Returns list of tensor indices given their names and their types. Parameters ========== s : string of comma separated names of indices typ : ``TensorIndexType`` of the indices Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> a, b, c, d = tensor_indices('a,b,c,d', Lorentz) Tseqexpecting a stringrer)rrrrgriryrN)r rnrErrYtilists r4tensor_indicesr0Ss|$!S$QD1 21VV1 2-..+, -1ak!!1F - 6{aay M 3.s A6 A;c\rSrSrSrSr\S5r\S5r\S5r \ S5r \ S5r \ S 5r \ S 5rS rg ) ripa Monoterm symmetry of a tensor (i.e. any symmetric or anti-symmetric index permutation). For the relevant terminology see ``tensor_can.py`` section of the combinatorics module. Parameters ========== bsgs : tuple ``(base, sgs)`` BSGS of the symmetry of the tensor Attributes ========== ``base`` : base of the BSGS ``generators`` : generators of the BSGS ``rank`` : rank of the tensor Notes ===== A tensor can have an arbitrary monoterm symmetry provided by its BSGS. Multiterm symmetries, like the cyclic symmetry of the Riemann tensor (i.e., Bianchi identity), are not covered. See combinatorics module for information on how to generate BSGS for a general index permutation group. Simple symmetries can be generated using built-in methods. See Also ======== sympy.combinatorics.tensor_can.get_symmetric_group_sgs Examples ======== Define a symmetric tensor of rank 2 >>> from sympy.tensor.tensor import TensorIndexType, TensorSymmetry, get_symmetric_group_sgs, TensorHead >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> sym = TensorSymmetry(get_symmetric_group_sgs(2)) >>> T = TensorHead('T', [Lorentz]*2, sym) Note, that the same can also be done using built-in TensorSymmetry methods >>> sym2 = TensorSymmetry.fully_symmetric(2) >>> sym == sym2 True c[U5S:XaUSup4O[U5S:XaUup4O [S5e[U[5(d[U6n[U[5(d[U6n[R "XU40UD6$)NrerrAz:bsgs required, either two separate parameters or one tuple)rN TypeErrorrrrr)rrkw_argsrrs r4rTensorSymmetry.__new__s t9>#Aw D* Y!^# D*XY Y$&&$g>>r3c URS$rCrrts r4rTensorSymmetry.baserr3c URS$rrrts r4rTensorSymmetry.generatorsrr3c:URSRS- $)NrrA)rsizerts r4rTensorSymmetry.ranksq!&&**r3cUS:a [US5nO(US:a[U*S5nOUS:Xa/[S5/4n[W5$)zj Returns a fully symmetric (antisymmetric if ``rank``<0) TensorSymmetry object for ``abs(rank)`` indices. rFTre)rr r)rrbsgss r4rTensorSymmetry.fully_symmetricsO !8*47D AX*D5$7D QYQ()Dd##r3c/[S5/p2UH:nUS:a [US5nOUS:a[U*S5nOM,[X#/UQ76up#M< [X#5$)aF Returns a TensorSymmetry object that is being a direct product of fully (anti-)symmetric index permutation groups. Notes ===== Some examples for different values of ``(*args)``: ``(1)`` vector, equivalent to ``TensorSymmetry.fully_symmetric(1)`` ``(2)`` tensor with 2 symmetric indices, equivalent to ``.fully_symmetric(2)`` ``(-2)`` tensor with 2 antisymmetric indices, equivalent to ``.fully_symmetric(-2)`` ``(2, -2)`` tensor with the first 2 indices commuting and the last 2 anticommuting ``(1, 1, 1)`` tensor with 3 indices without any symmetry rerFT)r rrr)rrrsgsr*bsgs2s r4direct_productTensorSymmetry.direct_productsg Q(cCQw/U;q/d;+D>>ID#d((r3c [[5$)z4 Returns a monotorem symmetry of the Riemann tensor )rr)rs r4riemannTensorSymmetry.riemanns l++r3c4[/[US-5/5$)z= TensorSymmetry object for ``rank`` indices with no symmetry re)rr )rrs r4rTensorSymmetry.no_symmetrys b;tAv#6"788r3r2N)rrrrrrrrrr classmethodrrCrFrrr2r3r4rrps.^ ?++ $ $))6,, 99r3rzf The tensorsymmetry() function is deprecated. Use the TensorSymmetry constructor instead. r7zdeprecated-tensorsymmetryrcTSSKJn SnU(d#[[5[U"S555$[ U5S:Xa"[ USSU5(a [U5$U"US5up4USSHnU"U5upg[ X4Xg5up4M [[X455$)a  Returns a ``TensorSymmetry`` object. This method is deprecated, use ``TensorSymmetry.direct_product()`` or ``.riemann()`` instead. Explanation =========== One can represent a tensor with any monoterm slot symmetry group using a BSGS. ``args`` can be a BSGS ``args[0]`` base ``args[1]`` sgs Usually tensors are in (direct products of) representations of the symmetric group; ``args`` can be a list of lists representing the shapes of Young tableaux Notes ===== For instance: ``[[1]]`` vector ``[[1]*n]`` symmetric tensor of rank ``n`` ``[[n]]`` antisymmetric tensor of rank ``n`` ``[[2, 2]]`` monoterm slot symmetry of the Riemann tensor ``[[1],[1]]`` vector*vector ``[[2],[1],[1]`` (antisymmetric tensor)*vector*vector Notice that with the shape ``[2, 2]`` we associate only the monoterm symmetries of the Riemann tensor; this is an abuse of notation, since the shape ``[2, 2]`` corresponds usually to the irreducible representation characterized by the monoterm symmetries and by the cyclic symmetry. rr c[U5S:XaUSn[US5nU$[SU55(a[U5n[U5nU$USS/:Xa[nU$[e)Nrerc3*# UH oS:Hv M g7f)reNr2rrEs r4r7tensorsymmetry..tableau2bsgs..(s%1a61srA)rNrrrNotImplementedError)rrkr>s r4 tableau2bsgs$tensorsymmetry..tableau2bsgs"sw q6Q;!A*1a0D %1%%%F.q1  q!f# *)r3rerAN)sympy.combinatoricsr rrrNrr)rr rQrrArbasexsgsxs r4tensorsymmetryrVsX0 egu[^'<== 4yA~*T!WQZ==d##T!W%ID !"X"1o '5? c %* ++r3z5TensorType is deprecated. Use tensor_heads() instead.zdeprecated-tensortypecb\rSrSrSrSrSr\S5r\S5r \S5r Sr S S jr S r g ) TensorTypei=a5 Class of tensor types. Deprecated, use tensor_heads() instead. Parameters ========== index_types : list of ``TensorIndexType`` of the tensor indices symmetry : ``TensorSymmetry`` of the tensor Attributes ========== ``index_types`` ``symmetry`` ``types`` : list of ``TensorIndexType`` without repetitions Fc zUR[U5:Xde[R"U[ U6U40UD6nU$r])rrNrrr)rrLrr4rs r4rTensorType.__new__Us:}}K 0000mmC !4hJ'J r3c URS$rCrrts r4rLTensorType.index_typesZrr3c URS$rrrts r4rTensorType.symmetry^rr3c>[[UR5SS9$)NcUR$r]rrDs r4rF"TensorType.types..ds166r3rH)rsetrLrts r4typesTensorType.typesbsc$**+1ABBr3c^SURVs/sHn[U5PM sn-$s snf)NzTensorType(%s))rLrrQrEs r4rTensorType.__str__fs+D4D4D#E4DqCF4D#EFF#Es*c j[U[5(a$[USS9Vs/sHo3RPM nnO [ S5e[ U5S:Xa%[ USURURU5$UVs/sH$n[ XPRURU5PM& sn$s snfs snf)z Return a TensorHead object or a list of TensorHead objects. Parameters ========== s : name or string of names. comm : Commutation group. see ``_TensorManager.set_comm`` Tr,r.rer) rrrrgrirNrrLr)rQr rrEnamesrgs r4rTensorType.__call__is a  %,QD%9:%9VV%9E:E12 2 u:?eAh(8(8$--N NX]^X]PTJt%5%5t}}dKX]^ ^ ; _s B+=+B0r2N)r)rrrrris_commutativerrrLrrcrrrr2r3r4rXrX=s]  N CCG_r3rXzN The tensorhead() function is deprecated. Use tensor_heads() instead. zdeprecated-tensorheadcUc%[[U55Vs/sHnS/PM nn[[5 [ U6nSSS5 [ XX#5$s snf!,(df  N=f)aG Function generating tensorhead(s). This method is deprecated, use TensorHead constructor or tensor_heads() instead. Parameters ========== name : name or sequence of names (as in ``symbols``) typ : index types sym : same as ``*args`` in ``tensorsymmetry`` comm : commutation group number see ``_TensorManager.set_comm`` Nre)rrNr'r&rVr)rgrnrrrYs r4r;r;sX0 {!#c(O,OqsO, 0 1c" 2 d ++- 1 1s A A A(c\rSrSrSrSrSSjr\S5r\S5r \S5r \S 5r \S 5r S r S rS rSrSr\S5r\R&S5r\R(S5rSrSrSrg)ria4 Tensor head of the tensor. Parameters ========== name : name of the tensor index_types : list of TensorIndexType symmetry : TensorSymmetry of the tensor comm : commutation group number Attributes ========== ``name`` ``index_types`` ``rank`` : total number of indices ``symmetry`` ``comm`` : commutation group Notes ===== Similar to ``symbols`` multiple TensorHeads can be created using ``tensorhead(s, typ, sym=None, comm=0)`` function, where ``s`` is the string of names and ``sym`` is the monoterm tensor symmetry (see ``tensorsymmetry``). A ``TensorHead`` belongs to a commutation group, defined by a symbol on number ``comm`` (see ``_TensorManager.set_comm``); tensors in a commutation group have the same commutation properties; by default ``comm`` is ``0``, the group of the commuting tensors. Examples ======== Define a fully antisymmetric tensor of rank 2: >>> from sympy.tensor.tensor import TensorIndexType, TensorHead, TensorSymmetry >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> asym2 = TensorSymmetry.fully_symmetric(-2) >>> A = TensorHead('A', [Lorentz, Lorentz], asym2) Examples with ndarray values, the components data assigned to the ``TensorHead`` object are assumed to be in a fully-contravariant representation. In case it is necessary to assign components data which represents the values of a non-fully covariant tensor, see the other examples. >>> from sympy.tensor.tensor import tensor_indices >>> from sympy import diag >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> i0, i1 = tensor_indices('i0:2', Lorentz) Specify a replacement dictionary to keep track of the arrays to use for replacements in the tensorial expression. The ``TensorIndexType`` is associated to the metric used for contractions (in fully covariant form): >>> repl = {Lorentz: diag(1, -1, -1, -1)} Let's see some examples of working with components with the electromagnetic tensor: >>> from sympy import symbols >>> Ex, Ey, Ez, Bx, By, Bz = symbols('E_x E_y E_z B_x B_y B_z') >>> c = symbols('c', positive=True) Let's define `F`, an antisymmetric tensor: >>> F = TensorHead('F', [Lorentz, Lorentz], asym2) Let's update the dictionary to contain the matrix to use in the replacements: >>> repl.update({F(-i0, -i1): [ ... [0, Ex/c, Ey/c, Ez/c], ... [-Ex/c, 0, -Bz, By], ... [-Ey/c, Bz, 0, -Bx], ... [-Ez/c, -By, Bx, 0]]}) Now it is possible to retrieve the contravariant form of the Electromagnetic tensor: >>> F(i0, i1).replace_with_arrays(repl, [i0, i1]) [[0, -E_x/c, -E_y/c, -E_z/c], [E_x/c, 0, -B_z, B_y], [E_y/c, B_z, 0, -B_x], [E_z/c, -B_y, B_x, 0]] and the mixed contravariant-covariant form: >>> F(i0, -i1).replace_with_arrays(repl, [i0, -i1]) [[0, E_x/c, E_y/c, E_z/c], [E_x/c, 0, B_z, -B_y], [E_y/c, -B_z, 0, B_x], [E_z/c, B_y, -B_x, 0]] Energy-momentum of a particle may be represented as: >>> from sympy import symbols >>> P = TensorHead('P', [Lorentz], TensorSymmetry.no_symmetry(1)) >>> E, px, py, pz = symbols('E p_x p_y p_z', positive=True) >>> repl.update({P(i0): [E, px, py, pz]}) The contravariant and covariant components are, respectively: >>> P(i0).replace_with_arrays(repl, [i0]) [E, p_x, p_y, p_z] >>> P(-i0).replace_with_arrays(repl, [-i0]) [E, -p_x, -p_y, -p_z] The contraction of a 1-index tensor by itself: >>> expr = P(i0)*P(-i0) >>> expr.replace_with_arrays(repl, []) E**2 - p_x**2 - p_y**2 - p_z**2 FNc X[U[5(a [U5nO#[U[5(aUnO [S5eUc[R [ U55nOUR[ U5:Xde[R"X[U6U[U55nU$)Nr) rrrrirrrNrrrrr)rrgrLrrrrs r4rTensorHead.__new__s dC  ,K f % %K^, ,  %11#k2BCH==C $44 44mmCe[.A8WUY][ r3c4URSR$rCrrts r4rgTensorHead.name!rr3c2[URS5$rrrrts r4rLTensorHead.index_types%sDIIaL!!r3c URS$rrrts r4rTensorHead.symmetry)rr3cF[RURS5$r)rrrrts r4rTensorHead.comm-s++DIIaL99r3c,[UR5$r])rNrLrts r4rTensorHead.rank1s4##$$r3cdURUR4URUR4:$r])rgrLrs r4rTensorHead.__lt__5s+ 4++, E>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorSymmetry, TensorHead >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> a, b = tensor_indices('a,b', Lorentz) >>> A = TensorHead('A', [Lorentz]*2, TensorSymmetry.no_symmetry(2)) >>> t = A(a, -b) >>> t A(a, -b)  -reNFrh) r rLrrstripreplace startswithrjryrNrdoit)rQrMr4updated_indicesrzrnr?s r4rTensorHead.__call__Ds>G%5%56HC#s##iik))#r2>>#&&#**;s12w16,89$**;s+@A&&s+7 3#7#89999{{}r3c [5 [[5 URc [ S5eSSKJnJn URVs/sHoDRPM nnURnUR5nUH nU"XhU5nU"USU4US-US-45nM" Xa[R--sSSS5 $s snf!,(df  g=f)NzNo power on abstract tensors.rerlrrA) r5r'r&rrirr0r1rLrrHalf) rQrr0r1rmetricsmarray marraydimrs r4__pow__TensorHead.__pow__vs 4 5yy  !@AA ?'+'7'78'7!vv'7G8YYF I!&vv>*6Ay>IaKQZ[\Q\C]^"affn-6 59 6 5s/C CACC Cc|[5 [[5 [UsSSS5 $!,(df  g=fr]rrts r4rTensorHead.datarrc|[5 [[5 U[U'SSS5 g!,(df  g=fr]rrQrs r4rr( 4 537 *4 06 5 5 - ;c<[5 U[;a[U ggr])r5rrts r4rrs 1 1.t4 2r3c[5 [[5 URR 5sSSS5 $!,(df  g=fr]r5r'r&r__iter__rts r4rTensorHead.__iter__- 4 599%%'6 5 5 > A c^[5 URS:XagU[;a[U gg)z EXPERIMENTAL: do not rely on this API method. Destroy components data associated to the ``TensorHead`` object, this checks for attached components data, and destroys components data too. rN)r5rgrrts r4r(TensorHead._components_data_full_destroys1  99   1 1.t4 2r3r2rC)rrrrrrkrrrgrLrrrrrr!rrrrrrrrr2r3r4rrsn^N !!""::%%OS.d. 88  [[88  \\55 ( 5r3rc [U[5(a$[USS9Vs/sHoDRPM nnO [ S5eUVs/sHn[ XaX#5PM nn[ U5S:XaUS$U$s snfs snf)z5 Returns a sequence of TensorHeads from a string `s` Tr,r.rer)rrrrgrirrN)r rLrrrErirgthlists r4 tensor_headsrs!S!(!56!5A!56-..HM NjH;F N 6{aay M7Os A7 A<cr\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSr\\S55r\\S55r\S5r\S'Sj5r\S(Sj5rSrSr\S5rSrSrSr \S5r!\S5r"\S5r#\S5r$\S 5r%S)S"jr&S#r'S$r(S*S%jr)S&r*g!)+ria Abstract base class for tensor expressions Notes ===== A tensor expression is an expression formed by tensors; currently the sums of tensors are distributed. A ``TensExpr`` can be a ``TensAdd`` or a ``TensMul``. ``TensMul`` objects are formed by products of component tensors, and include a coefficient, which is a SymPy expression. In the internal representation contracted indices are represented by ``(ipos1, ipos2, icomp1, icomp2)``, where ``icomp1`` is the position of the component tensor with contravariant index, ``ipos1`` is the slot which the index occupies in that component tensor. Contracted indices are therefore nameless in the internal representation. g(@Fc(U[R-$r])r NegativeOnerts r4r(TensExpr.__neg__sAMM!!r3c[er]rPrts r4__abs__TensExpr.__abs__!!r3c2[X5RSS9$NFdeeprrrs r4__add__TensExpr.__add__st#((e(44r3c2[X5RSS9$rrrs r4__radd__TensExpr.__radd__u#((e(44r3c4[X*5RSS9$rrrs r4__sub__TensExpr.__sub__stV$))u)55r3c4[X*5RSS9$rrrs r4__rsub__TensExpr.__rsub__sue$))u)55r3c2[X5RSS9$)a! Multiply two tensors using Einstein summation convention. Explanation =========== If the two tensors have an index in common, one contravariant and the other covariant, in their product the indices are summed Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensor_heads('p,q', [Lorentz]) >>> t1 = p(m0) >>> t2 = q(-m0) >>> t1*t2 p(L_0)*q(-L_0) Frrrrs r4__mul__TensExpr.__mul__s.t#((e(44r3c2[X5RSS9$rrrs r4__rmul__TensExpr.__rmul__rr3c[U5n[U[5(a [S5e[ U[ R U- 5RSS9$)Ncannot divide by a tensorFr)r!rrrirrOnerrs r4 __truediv__TensExpr.__truediv__ sG eX & &89 9tQUU5[)..E.::r3c[S5e)Nr)rirs r4 __rtruediv__TensExpr.__rtruediv__s455r3c [5 [[5 URc [ S5eSSKJnJn URnURnUR5nUH6nU"U"UUSRRU5SU4US-US-45nM8 XQ[R--sSSS5 $!,(df  g=f)NzNo power without ndarray data.rerlrrA) r5r'r&rrirr0r1rJrrWrr)rQrr0r1rJrrmrs r4rTensExpr.__pow__s 4 5yy  !ABB ?99DYYF;;=D*!1I//44IQQ/ affn-6 5 5s BB== C c[er]rrs r4__rpow__TensExpr.__rpow__%rr3c[S5eNzabstract methodrrts r4nocoeffTensExpr.nocoeff(""344r3c[S5errrts r4r'TensExpr.coeff-rr3c[S5errrts r4ruTensExpr.get_indices2!"344r3c[S5errrts r4rTensExpr.get_free_indices6rr3c[S5errrQrepls r4_replace_indicesTensExpr._replace_indices:rr3c4[5 UR"U6$r])r9substitute_indices)rQ index_tupless r4fun_evalTensExpr.fun_eval>s&& 55r3cXSSKJn [5 [[5 SUR s=:aS::aO OUR RSnUR S:XaUR RSOSnUR S:XaR/U-n[U5H=nUR/5 [U5HnXERXU45 M M? OS/U-n[U5H nXXE'M U"U5sSSS5 $[S5e!,(df  g=f)z DEPRECATED: do not use. Returns ndarray components data as a matrix, if components data are available and ndarray dimension does not exceed 2. r)MatrixrAreNz-missing multidimensional reduction to matrix.) sympy.matrices.denserr5r'r&rrrTrrjrP)rQrrowscolumnsmat_listrYrs r4 get_matrixTensExpr.get_matrixBs 0 4 5499!!yyq)04 Q$))//!,A99>!DyH"4[ +!&wA$K..tqDz:"0) !%v}H"4[&*g )h'6 5 *CEE!6 5sC&D D D)cNUVs/sHo RU5PM sn$s snfr]rm)indices1indices2rYs r4_get_indices_permutation!TensExpr._get_indices_permutation^s!+348aq!8444s"c[5nURH9n[U[5(dMUR UR 55 M; U$r])rbrrrupdate_get_free_indices_setrQindsetr*s r4rTensExpr._get_free_indices_setbs@99C#x(( c779: r3c[5nURH9n[U[5(dMUR UR 55 M; U$r])rbrrrr_get_dummy_indices_setrs r4rTensExpr._get_dummy_indices_setis@99C#x(( c88:; r3c[5nURH9n[U[5(dMUR UR 55 M; U$r])rbrrrr_get_indices_setrs r4rTensExpr._get_indices_setps@99C#x(( c2245 r3cF^^UR5mUU4SjmT"US5$)Nc3># [U[5(a UT;aX4v gg[U[[45(a3[ UR 5Hup#T"X1U4-5ShvN M ggN 7fr]rryrrrfr)exprrqpr* dummy_setrecursors r4r1TensExpr._iterate_dummy_indices..recursor{sk$ ,,9$+%%D5("344' 2FA'!X666356A'A7*A5+ A7r2)r)rQrrs @@r4_iterate_dummy_indicesTensExpr._iterate_dummy_indicesws%//1  7b!!r3cF^^UR5mUU4SjmT"US5$)Nc3># [U[5(a UT;aX4v gg[U[[45(a3[ UR 5Hup#T"X1U4-5ShvN M ggN 7fr]r )r rqr r*free_setrs r4r0TensExpr._iterate_free_indices..recursorsk$ ,,8#+%$D5("344' 2FA'!X666356rr2)r)rQrrs @@r4_iterate_free_indicesTensExpr._iterate_free_indicess%--/ 7b!!r3c"^U4SjmT"US5$)Nc3># [U[5(aX4v g[U[[45(a3[ UR 5Hup#T"X1U4-5ShvN M ggN 7fr]r )r rqr r*rs r4r+TensExpr._iterate_indices..recursors^$ ,,k!D5("344' 2FA'!X666356sA A0#A.$ A0r2r2)rQrs @r4_iterate_indicesTensExpr._iterate_indicess 7b!!r3cSSKJnJnJn U"U"X5SSU-45n[ [ U55nXrUSsUS'Xr'U"X5$)Nre)r1r0rrAr)rr1r0rrr)rrrqrUr1r0rpermus r4!_contract_and_permute_with_metric*TensExpr._contract_and_permute_with_metricsU IH!-">AcE KU3Z $z58a%*5((r3c SSKJn UVs/sHoURPM nn/n/nUSSn [U5HupX;aU R U 5n SX'M!U *U ;aQU R U *5n SX'XU 'U R (aUR U 5 MfUR U 5 MyXn U c[SU<SU<35eSX'XU 'U R U R - (dMU R (aUR U 5 MUR U 5 M [[U5[U5-5[U5:a[SU<SU<35eUHPnXnnX;a [S5eX?n[RU5n[RUX[U55nMR UH;nXnnX;a [S5eX?n[RUX[U55nM= U(a[RX!5nU"UU5n[US5(aUR!5S:XaUSnX 4$s snf) Nrerzincompatible indices: z and z!No metric provided to lower indexrrr2)rrrWrfrmrhrjrirNrbrrurr!rrr)r free_ind1 free_ind2replacement_dictrrY index_types1pos2uppos2downfree2remainingr|index1r}index2rqindex_type_posrmetric_inversers r4 _match_indices_with_other_tensor)TensExpr._match_indices_with_other_tensors3&5>?Y++Y ?"1%i0LD'%++F3'+$w.(%++VG4'+$"($<<MM$'OOD)'->$)U^%_``'+$"($<<&,,..|| d+ -/12 s9~I. /#i. @)YWX XC).N5 !DEE%5F5DDVLN>>~u[^_h[ijE C).N5 !DEE%5F>>vuSVW`SabE  ";;IQK{3E 5& ! !ejjla&7"IEs@sINc SSKJn U=(d /nUR5Vs0sH3oDR(aURSOURS*U_M5 nn[ U5H7upg[ U[[45(dM"Xu;aXWX&'M/XW**X&'M9 UR5VV s0sH upX"U 5_M nnn UR5Hup[ U[5(a%[S5Vs/sHohRPM n nO%URV s/sHoRPM n n [U 5U R5:wd-[!S[#U U R$555(aM['SU<SU <SU R$<35e UR)U5upUR+XX5upU $s snfs sn nfs snfs sn f) a Replace the tensorial expressions with arrays. The final array will correspond to the N-dimensional array with indices arranged according to ``indices``. Parameters ========== replacement_dict dictionary containing the replacement rules for tensors. indices the index order with respect to which the array is read. The original index order will be used if no value is passed. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices >>> from sympy.tensor.tensor import TensorHead >>> from sympy import symbols, diag >>> L = TensorIndexType("L") >>> i, j = tensor_indices("i j", L) >>> A = TensorHead("A", [L]) >>> A(i).replace_with_arrays({A(i): [1, 2]}, [i]) [1, 2] Since 'indices' is optional, we can also call replace_with_arrays by this way if no specific index order is needed: >>> A(i).replace_with_arrays({A(i): [1, 2]}) [1, 2] >>> expr = A(i)*A(j) >>> expr.replace_with_arrays({A(i): [1, 2]}) [[1, 2], [2, 4]] For contractions, specify the metric of the ``TensorIndexType``, which in this case is ``L``, in its covariant form: >>> expr = A(i)*A(-i) >>> expr.replace_with_arrays({A(i): [1, 2], L: diag(1, -1)}) -3 Symmetrization of an array: >>> H = TensorHead("H", [L, L]) >>> a, b, c, d = symbols("a b c d") >>> expr = H(i, j)/2 + H(j, i)/2 >>> expr.replace_with_arrays({H(i, j): [[a, b], [c, d]]}) [[a, b/2 + c/2], [b/2 + c/2, d]] Anti-symmetrization of an array: >>> expr = H(i, j)/2 - H(j, i)/2 >>> repl = {H(i, j): [[a, b], [c, d]]} >>> expr.replace_with_arrays(repl) [[0, b/2 - c/2], [-b/2 + c/2, 0]] The same expression can be read as the transpose by inverting ``i`` and ``j``: >>> expr.replace_with_arrays(repl, [j, i]) [[0, -b/2 + c/2], [b/2 - c/2, 0]] reArrayrrAc3T# UHupUR(aX:HOSv M g7f)TN)rV)rrrs r4r/TensExpr.replace_with_arrays..< s0?<ZT@D|$(@)<s&(zshapes for tensor z expected to be z, replacement array shape is )rr3rrhrrfrrritemsrHrrUrLrNrrr rTri _extract_datar/)rQr&rMr3kremaprYrmr?rexpected_shape index_type ret_indices last_indicess r4replace_with_arraysTensExpr.replace_with_arrayssD !-RBFBWBWBYZBYQggAFF1I:q8BYZ!'*HA%&#//>!&GJ"'-GJ +GWF\F\F^_F^]VFE%L0F^_.335MF&/226;Ah!?h**h!?CICUCU!VCUZ..CU!V>"ejjl23?;>~ <?<<!7=~KK"!""6"//0@A "CCET_r  5[` "@!Vs:G9GG%-G*cSSKJn UR5nURnUVVs/sH%upgX&SXFRR S- 4PM' nnnU(a U"U/UQ76nU$s snnf)NrSumre)sympy.concrete.summationsrBrurKrWrU) rQr  index_symbolsrBrMrKrYr sum_indicess r4_check_add_SumTensExpr._check_add_SumH s}1""$hhrFrJrPrr2r3r4rrsl.LN""5566525; 6.&"55555555556E855 " " " """))< < |_B)r3rcl\rSrSrSrSr\S5r\S5rS"Sjr S#Sjr \ S5r \ S 5r \ S 5rS$S jr\S 5r\S 5r\S5rSrSrSrSrSrSrSrSrSrSr\S5r\R>S5r\R@S5rSr!Sr"Sr#S%S jr$S!r%g)&riq a| Sum of tensors. Parameters ========== free_args : list of the free indices Attributes ========== ``args`` : tuple of addends ``rank`` : rank of the tensor ``free_args`` : list of the free indices in sorted order Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_heads, tensor_indices >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> a, b = tensor_indices('a,b', Lorentz) >>> p, q = tensor_heads('p,q', [Lorentz]) >>> t = p(a) + q(a); t p(a) + q(a) Examples with components data added to the tensor expression: >>> from sympy import symbols, diag >>> x, y, z, t = symbols("x y z t") >>> repl = {} >>> repl[Lorentz] = diag(1, -1, -1, -1) >>> repl[p(a)] = [1, 2, 3, 4] >>> repl[q(a)] = [x, y, z, t] The following are: 2**2 - 3**2 - 2**2 - 7**2 ==> -58 >>> expr = p(a) + q(a) >>> expr.replace_with_arrays(repl, [a]) [x + 1, y + 2, z + 3, t + 4] c,UVs/sHo3(dM [U5PM nn[RU5nUR[S9 U(d[ R $[U5S:XaUS$[R"U/UQ70UD6$s snf)NrHrer) r!r_tensAdd_flattenrPrrrMrNrr)rrr4rEs r4rTensAdd.__new__ s{%)/TQ  T/''- & '66M t9>7N}}S3437330s BBc"[R$r]rrrts r4r' TensAdd.coeff uu r3cU$r]r2rts r4rTensAdd.nocoeff  r3cUR$r]) free_indicesrts r4rTensAdd.get_free_indices s   r3cURVs/sH+n[U[5(aURU5OUPM- nnUR"U6$s snfr])rrrrrI)rQrr*newargss r4rTensAdd._replace_indices sQ_c_h_hi_hX[C1J1J3''-PSS_hiyy'""js2Acz[URS[5(aURSR$grC)rrrrrts r4r TensAdd.rank s. diilH - -99Q<$$ $r3c|[URS[5(aURSR$/$rC)rrrr!rts r4r!TensAdd.free_args s0 diilH - -99Q<)) )Ir3c[URS[5(aURSR5$[ 5$rC)rrrrrbrts r4raTensAdd.free_indices s5 diilH - -99Q<002 25Lr3c \URSS5nU(a,URVs/sHo3R"S0UD6PM nnO URnUVs/sHo3[R:wdMUPM nn[ U5S:Xa[R$[ U5S:XaUS$[ RU5 [ RU5nSnURUS9 U(d[R$[ U5S:XaUS$UR"U6nU$s snfs snf)NrTrrec[U[5(d///4$[US5(a?[US5(a.[U5nURUR UR 4$///4$)N_index_structurer`)rrrget_index_structurer`rJrK)rrEs r4sort_keyTensAdd.doit..sort_key sda**2rz!q,--'!\2J2J'*||QVVQUU22r2: r3rHr2) rrrrrMrNr_tensAdd_check_tensAdd_collect_termsrPrI)rQhintsrr*rrprs r4r TensAdd.doit syy& 15;#HH%u%D;D99D $5taff}t5 t9>66M Y!^7N t$--d3  h 66M t9>7Nii G< 6sD$D)1D)c/nUHUn[U[[45(a&UR[ UR 55 MDUR U5 MW UVs/sHo"R(dMUPM nnU$s snfr])rrrr^rrrjr')rrrEs r4rWTensAdd._tensAdd_flatten sg A!c7^,,aff&  (1a1( )s "B:Bc^SSjnU"US5mUSSVs/sH o!"U5PM nn[U4SjU55(d [S5egs snf)Ncr[U[5(a[UR55$[5$r])rrrbrrDs r4get_indices_set/TensAdd._tensAdd_check..get_indices_set s*!X&&1--/005Lr3rrec3,># UH oT:Hv M g7fr]r2)rrEindices0s r4r)TensAdd._tensAdd_check.. s7,Q=,sz&all tensors must have the same indices)rErrzset[TensorIndex])rri)rrzr* list_indicesr}s @r4rrTensAdd._tensAdd_check s_  #47+8E7#E7c/nURH5nUR[U5Vs/sH o3U;dM UPM sn5 M7 U$s snfr])rr^ru)rQrMr*rYs r4ruTensAdd.get_indices) sG99C NN{3'7L'7!G;KA'7L MMs A A c[5 URn[U5nUVs/sHo3RPM snUVs/sHo3RPM sn:wa [ S5eX:XaU$[[ X!55nUR Vs/sH(o3R"UR"U6R 6PM* nn[U6RSS9nU$s snfs snfs snf)Nincompatible typesFr) r<r!rrWrir rrIrrr)rQrMr!rErrress r4rTensAdd.__call__0 sNN w-)0 1A   1S\5]S\a6I6IS\5] ]12 2  KC 34 HL R 1VVQ))<8== >  RqkE*  25] SsCC/C"cUR5n[XR5(a<URVs/sHn[ U5PM nn[ U6R SS9nU$[ U5$s snf)zb Canonicalize using the Butler-Portugal algorithm for canonicalization under monoterm symmetries. Fr)expandrrIrrRrr)rQr rErrs r4rRTensAdd.canon_bp= se {{} dII & &)-3AHQKD34.%%5%1CJD> ! 4sA2c<[U5n[U[5(a,URS:Xa[ SUR 55$[U[ 5(aURUR:wag[U[5(a.[UR 5[UR 5:waggX- n[U[ 5(dUS:H$[U[5(aURS:H$[ SUR 55$)Nrc3># UHoRS:Hv M g7frNr'rNs r4r!TensAdd.equals..M s7Yww!|YFTc3># UHoRS:Hv M g7frrrNs r4rr] s8A77a<r) r!rrr'rrrrrrb)rQrrs r4equalsTensAdd.equalsJ s eW % %%++*:7TYY77 7 eX & &yyEJJ& eW % %499~UZZ0 L!X&&6M!W%%ww!|#8888r3c[5 [[5 URUsSSS5 $!,(df  g=fr]r5r'r&rrQitems r4rTensAdd.__getitem___ ( 4 599T?6 5 5 3 AcURVs/sH+n[U[5(aURU5OUPM- nn[ U6R SS9n[ U5$s snfr)rrrcontract_deltarrrR)rQrrErrs r4rTensAdd.contract_deltad saSWS\S\]S\a:a+B+B  'IS\] TN  U  +{^s2A#cURVs/sHn[X!5PM nn[U6RSS9n[ U5$s snf)z Raise or lower indices with the metric ``g``. Parameters ========== g : metric contract_all : if True, eliminate all ``g`` which are contracted Notes ===== see the ``TensorIndexType`` docstring for the contraction conventions Fr)rcontract_metricrrrR)rQrrErrs r4rTensAdd.contract_metrici sG"04yy9y!%y9 TN  U  +{:sAc/nURH8n[U[5(aUR"U6nUR U5 M: [ U6R SS9$r)rrrrrjrrrQrrr*s r4rTensAdd.substitute_indices~ Y99C#x((,,l; OOC !&&E&22r3c/nURnUHnUR[U55 M SRU5nUR SS5nU$)Nz + z+ -z- )rrjrrr)rQrrrEr s r4r!TensAdd._print sL yyA HHSV  JJqM IIeT "r3c SSKJnJn [URVs/sH-n[ U[ 5(aURU5O/U4PM/ sn6upVUVs/sH or"U5PM nnUSn[S[U55H*nXWn Xgn [RX5n U"X5Xg'M, U[XbR"W R654$s snfs snf)Nr)r3rre)sympy.tensor.arrayr3rr rrrr7rrNrrsumrrT) rQr&r3rr* args_indicesr5rY ref_indicesrMrrs r4r7TensAdd._extract_data s9"@D % @IJsH % %   . /,.9 5@I%   %++Fq%(F+"1o q#l+,A"oGIE!::7PK#E7FI - C U[[(ABBB% ,s 4CCc[5 [[5 [UR 5sSSS5 $!,(df  g=fr]r5r'r&rrrts r4r TensAdd.data s+ 4 51$++-@6 5 5s ; A c|[5 [[5 U[U'SSS5 g!,(df  g=fr]rrs r4rr rrc[5 [[5 U[;a[U SSS5 g!,(df  g=fr]rrts r4rr s. 4 5552486 5 5s 5 Ac[5 UR(d [S5eURR5R 5$Nz No iteration on abstract tensors)r5rriflattenrrts r4rTensAdd.__iter__ s7yy?@ @yy  "++--r3c.[R"U5$r])rfromiter)rQrrs r4_eval_rewrite_as_Indexed TensAdd._eval_rewrite_as_Indexed s||D!!r3c8/nURHmn[U[5(a"URUR U55 M:UR (dMMURUR U55 Mo UR"U6RSS9$r) rrrrj_eval_partial_derivative _diff_wrt_eval_derivativerIr)rQr  list_addendsrs r4r TensAdd._eval_partial_derivative s| A!X&&##A$>$>q$AB##A$6$6q$9: yy,',,%,88r3Ncv[U5nUc0nOUR5n[U[5(dg[ [ U55S:XaUR XU5$Sn[URU5n[URU5n/nUSHZnSn USHCn X;aM URXUS9n U cMSn URU 5 URU 5 O U (aMZ g USV s/sH oU;dM U PM n n USHrnU HinURU5n U cMURU5 XR5;aX.==U RU5- ss'URU 5 Mk Mt USV s/sH oU;dM U PM n n USHnU HnURU5n U cMURU5 URUR5;a/X.R==U RUR5- ss'URU 5 M M USV s/sH oU;dM U PM n n US HnU HnURU5n U cMURU5 URUR5;a/X.R==U RUR5- ss'URU 5 M M USV s/sH oU;dM U PM n n [ U 5S:agU$s sn fs sn fs sn fs sn f) Nrc[U5n[U[5n[U5S:Xag[UR 5;a,USH"n[UR 55S:XdM" g gg)Nrnonwild WildTensorindexless_wildtensor wildtensor otherwild) _get_wildsr*typerNrkeysru)r* wildatomswildatom_typesws r4siftkey TensAdd.matches..siftkey sd"3I!)T2N9~" ~2244' 5A1==?+q056$"r3rF)rOrTrrr)rr~rrrNrrPr*rmatchesrrjrpopra)rQr rOrr query_sifted expr_siftedmatched_e_tensorsq_tensormatched_this_qe_tensorrgrremaining_e_tensorsres r4rTensAdd.matches st}  I!(I$(( z$ A %''= = #DIIw/ 499g. $Y/H"N' 20$$X$L9%)N$$Q'%,,X63">!0$+6i*@_*@QM^D^q*@_k*A(IIaL=%,,Q/NN,,! a0 $$Q' )++6i*@_*@QM^D^q*@_l+A(IIaL=%,,Q/{{inn&66!++.!%% 2DD.$$Q' ),+6i*@_*@QM^D^q*@_45A(IIaL=%,,Q/{{inn&66!++.!%% 2DD.$$Q' )6+6i*@_*@QM^D^q*@_ " #a ' E````s0= L' L' L,!L, L1L1 L6 L6r2rrR)rrrS)&rrrrrrrr'rrrr(rr!rarrrWrrrsrurrRrrrrrr!r7rrrrrrrrr2r3r4rrq sM'R 4!#   &P   G G8  "9*#  *3 CAA  [[88  \\99 . " 9Tr3rc~\rSrSr%SrSrS\S'S\S'SS.S jr\S 5r \S 5r \S 5r \S 5r \S5r \S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5rSr\S5rS=SjrSS.SjrSrSrSr\S5r\S5r\S 5r S!r!S=S"jr"S#r#S$r$S%r%S>S&jr&S>S'jr'S?S(jr(S)r)S*r*S+r+S@S-jr,S@S.jr-S/r.S0r/S1r0S2r1\S35r2\2RfS45r2\2RhS55r2S6r5S7r6S8r7S9r8S:r9SAS;jr:S>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead >>> Lorentz = TensorIndexType("Lorentz", dummy_name="L") >>> mu, nu = tensor_indices('mu nu', Lorentz) >>> A = TensorHead("A", [Lorentz, Lorentz]) >>> A(mu, -nu) A(mu, -nu) >>> A(mu, -mu) A(L_0, -L_0) It is also possible to use symbols instead of inidices (appropriate indices are then generated automatically). >>> from sympy import Symbol >>> x = Symbol('x') >>> A(x, mu) A(x, mu) >>> A(x, -x) A(L_0, -L_0) Fr>rnztuple[TensorHead, Tuple]rrc 0URX5n[R"X[U640UD6n[R "U6UlUR RSSUlUR RSSUl UR RUl [RUlXUlXlU/UlUR$['U5:wa [)S5eX5l[,R/X%R 5UlU$)Nwrong number of indices)_parse_indicesrrrr>rZrnrJ_freerK_dumrOrr_coeff_nocoeff _component _componentsrrNrirr_build_index_map _index_map)r tensor_headrMrr4rs r4rTensor.__new__F s$$[:mmCeWoII.;;WE((--a0 ''++A.,,66 UU  $&-   s7| +67 7%00:N:NO r3cUR$r]rrts r4rJ Tensor.freeW rr3cUR$r]rrts r4rK Tensor.dum[ s yyr3cUR$r]rOrts r4rTensor.ext_rank_ s ~~r3cUR$r]rrts r4r' Tensor.coeffc s {{r3cUR$r])rrts r4rTensor.nocoeffg s }}r3cUR$r])rrts r4raTensor.componentk s r3cUR$r])rrts r4r`Tensor.componentso sr3c URS$rCrrts r4head Tensor.heads rr3c URS$rrrts r4rMTensor.indicesw rr3cH[URR55$r])rbrnrrts r4raTensor.free_indices{ s4((99;<[RU/5up#pEUS$rC)r_tensMul_contract_indices)rQrtrrMrJrKs r4r Tensor.doit s"#*#D#DdV#L tAwr3c R[U[[[45(d[ S[ U5-5e[U5n[ U5Hup#[U[5(a[X0RUS5X'M7[U[5(aXUR5upEUS:Xa2[U[5(a[XPRUS5X'M[SU-5e[U[5(aM[ SU<S[ U5<35e U$)Nz"indices should be an array, got %sTrFzindex not understood: %szwrong type for index: z is ) rrrrr3rrfrryrLr as_coeff_Mulri)rrMrYrmrrs r4rTensor._parse_indices s'E4#788@4=PQ Qw-!'*HA%(((0G0G0JDQ E3''))+7z!V44!,Q0G0G0JE!RGJ$%?%%GHH{33E4PU; WXX+r3cFUR5nUR"USU06$Nrru _set_indicesrQimrrMs r4_set_new_index_structureTensor._set_new_index_structure $.."  'C{CCr3c[U5UR:wa [S5eURURSX!S9R 5$)Nindices length mismatchrr)rNrrirIrr)rQrrMr4s r4rTensor._set_indices sB w<4== (67 7yy1wyHMMOOr3c^URRVs1sHoSiM sn$s snfrC)rnrJrs r4rTensor._get_free_indices_set s*"338898!8999s*c[[R"URR65n[ UR S5VVs1sHup#X!;dM UiM snn$s snnfr)rb itertoolschainrnrKrfrrQ dummy_posrYrzs r4rTensor._get_dummy_indices_set sN )>)>)B)BCD "+DIIaL"9L"9Q^"9LLLs A%A%cF[URSR5$r)rbrrts r4rTensor._get_indices_set s499Q<$$%%r3cTURVVs/sH upXS4PM snn$s snnfrCrJ)rQrrqs r4 free_in_argsTensor.free_in_args s$.2ii8i(#1 i888s$cVURVVs/sH upXSS4PM snn$s snnfrC)rK)rQp1p2s r4 dum_in_argsTensor.dum_in_args s&-1XX6X62AX666s%c\[URVs/sHoSPM sn5$s snfrCrrfs r4r!Tensor.free_args %TYY/YtY/00/)c[U[5(dg[U[5(a%URR UR5$[ $)zd :param other: :return: 0 commute 1 anticommute None neither commute nor anticommute r)rrrrarrPrs r4rTensor.commutes_with s@%** v & &>>//@ @""r3c[XU5$)z Returns the tensor corresponding to the permutation ``g``. For further details, see the method in ``TIDS`` with the same name. rrQrrs r4rTensor.perm2tensor s 4K00r3cUR(aU$UR5nURR5up#n[ UR /5n[ X#U/UQ76nUS:Xa[R$URUS5nU$)NrT) rrrnrrrarrrMr)rQr rrrrcanr?s r4rRTensor.canon_bp s}   K{{}00CCED !4>>"2 31t0a0 !866M!!#t, r3cU/$r]r2rts r4r Tensor.split s v r3cU$r]r2rts r4sorted_componentsTensor.sorted_components s r3c2[URS5$)z> Get a list of indices, corresponding to those of the tensor. rersrts r4ruTensor.get_indices sDIIaL!!r3c6URR5$)zC Get a list of free indices, corresponding to those of the tensor. rnrrts r4rTensor.get_free_indices s$$5577r3c$URU5$r]xreplacers r4rTensor._replace_indices s}}T""r3c&U[R4$r]rZrts r4 as_base_expTensor.as_base_exp sQUU{r3cp/nURHnUH|upEURUR:XdM!URUR:XdM=URUR:XaUR U5 OUR U*5 M UR U5 M UR "U6$)a- Return a tensor with free indices substituted according to ``index_tuples``. ``index_types`` list of tuples ``(old_index, new_index)``. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads, TensorSymmetry >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) >>> A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2)) >>> t = A(i, k)*B(-k, -j); t A(i, L_0)*B(-L_0, -j) >>> t.substitute_indices((i, k),(-j, l)) A(k, L_0)*B(-L_0, l) )rMrgrWrhrjr)rQrrMrmind_oldind_news r4rTensor.substitute_indices s$\\E$0 JJ',,.53J3J3:3L3L4M{{gmm3w/x0%1u%"yy'""r3c URnURRnURnSnU1nXT:waUR 5nUHnUHnUR 5n[ SU5V s/sHoRU 5PM n n SURU5U- -n [[XV s/sHoU PM sn 55n URXRU 5-5 M M XT:waMU$s sn fs sn f)z\ Return a list giving all possible permutations of self that are allowed by its symmetries. Nrr) rarrrr~rurapplydictr addr) rQcompgensr old_perms new_permsrJgenindsrYpersignind_maps r4_get_symmetrized_formsTensor._get_symmetrized_forms s~~}}''yy F $!(I!C++-D16q?A99Q<C?#))D/D"89D"3ts-Cs!1gs-C#DEGMM4*?*?*H#HJ  "$ @-Cs 1C>2DNc4[U5nUc0nOUR5nX:XaU$[U[5(dgURUR:wagUR 5H+nUR XBUS9nUcMURU5 Us $ g)Nr)rr~rrrrb_matchesr)rQr rOrnew_exprrgs r4rTensor.matches5 st}  I!(I < $'' 99 !335H hs ;A}  #  6 r3c[U5nUc0nOUR5nX:XaU$[U[5(dgURUR:wagUR 5nUR 5n[ U5[ U5:wag[[ U55HSnXFnURXV5nUc gU*UR5;aX'**X:wa gURU5 MU U$)z4 This does not account for index symmetries of expr N) rr~rrrrurNrrrr) rQr rOr s_indices e_indicesrYs_indrgs r4rfTensor._matchesN st}  I!(I < $'' 99 !$$& $$& y>S^ +s9~&ALE il+Ay9>>++61B0Bah0N  #'r3c[5 URn[U5nUVs/sHo3RPM snUVs/sHo3RPM sn:wa [ S5eX:XaU$UR "[[ X!556n[UVs1sHoUR(aUOU*iM sn5[U5:waUR"UR6$U$s snfs snfs snfNr r<r!rrWrirr rNrhrIrrQrMr!rErrYs r4rTensor.__call__s NN w-)0 1A   1S\5]S\a6I6IS\5] ]12 2  K  # #T#i*A%B C g6gWW1"$g6 73w< G66166? " 25]7C&C+C0c[5 [[5 URR 5sSSS5 $!,(df  g=fr]rrts r4rTensor.__iter__ rrc[5 [[5 URUsSSS5 $!,(df  g=fr]rrs r4rTensor.__getitem__ rrc SSKJn UR5HBup4[U[5(dMUR SUR S:XdM>UnUn O [ U<SU<35eUR5VVs0sH up4X2"U5_M nnnU"U5nURnURn[U5S:a5UHn X;dM [SU-5e UV s/sH oU;dM U PM nn [U5S:aUR5n UR5n 0n UHupX*XU'X4H|nXRXR- (dM'XURnXR(a[RU5nURUXo[U 55nM~ M UR!U 5R#5n[R%U/U[U 55nUR'5nUR'5nUR)UUUU5$s snnfs sn f)Nrer2rz not found in z'%s with contractions is not implemented)rr3r6rrrrirKrNrPrurhrWrrur!rLrrrr/)rQr&r3r8rrrdum1dum2pairrrrr/r0rqrr$r%s r4r7Tensor._extract_data s $**,DA!V$$diil)B - T;KLM M5E4J4J4LM4LDAAuQxK4LMe xxyy t9q=#-.WZ_._`` &*>TT-=DTD> t9q='')H((*HD&.l]b\"8C}**X]-@-@@@!13-2Q2Q!R#=..%=%L%LV%TF $ F Fvu[^_g[h i $NN4(--/E,>>wcRZm\E))+ **, 44UIyRbcc?N?sH:( I5Ic|[5 [[5 [UsSSS5 $!,(df  g=fr]rrts r4r Tensor.data rrc|[5 [[5 U[U'SSS5 g!,(df  g=fr]rrs r4rr s( 4 537 *4 06 5 5rc[5 [[5 U[;a[U UR[;a[UR SSS5 g!,(df  g=fr]rrts r4rr rrcURVs/sHn[U5PM nnURnURS:a#UR<SSR U5<S3$SUR-$s snf)Nrrz, rz%s)rMrrarrgr)rQrrMras r4r! Tensor._print s_'+||4|3s8|4NN >>A  ) '0BC D9>>) * 5sA4cUS:XaURS:H$[U5n[U[5(d&UR(ae[ R U:H$SnU"U5U"U5:H$)NrcUR5nUR[UR5[[ UR 55[[ UR 554nU$r])rRr'rr`rrJrK)rQrr~s r4_get_compar_comp'Tensor.equals.._get_compar_comp sK A% -&.)5+?AAHr3)r'r!rrr`rr)rQrrs r4r Tensor.equals se A:::? "%** &&55E> !   %)9%)@@@r3c URU:waU$[UR5S:waU$UR[R S5:XaSnORUR[R S5:XaSnO,UR[R S5:XaSnO[e[RnURSnU(dX4R-nU$X4R-nURSupVXV:aU*nU$)NrrrerA) rarNrJrrrrrPrrrLrUrK)rQrantisymr`rndp0dp1s r4rTensor.contract_metric s >>Q K tyy>Q K ::77; ;G ZZ>99!< <G ZZ>55a8 8G% %uummA?,>q,> ?tyy|4m4""477@sAc[U[5(d[R$URUR:wa[R$S/n[ [ UR5UR555HunupEURUR:wa [S5eURnURn[S[U5-UURS9nURUR:XaURXE*5n O$[U"XH5URU*U*55n UR!U 5 M [R#U5R%SS9$)Nrezindex types not compatibled_rFr)rrrrMrrfr rrWrirryrrhrrrjrr) rQr kronecker_delta_listcountiselfiotherrW tensor_metricdummykroneckerdeltas r4rTensor._eval_partial_derivative sE!V$$66MyyAFF"vv %&3 -6c$:O:O:QSTSeSeSg6h,i(**f.F.FF$%ABB(-(?(?%$5$<$>E>J Jr3r2rrrRrS)r rrr)S;r?S<r@S=rASFS?jrBSFS@jrCSArDg>)GriB a Product of tensors. Parameters ========== coeff : SymPy coefficient of the tensor args Attributes ========== ``components`` : list of ``TensorHead`` of the component tensors ``types`` : list of nonrepeated ``TensorIndexType`` ``free`` : list of ``(ind, ipos, icomp)``, see Notes ``dum`` : list of ``(ipos1, ipos2, icomp1, icomp2)``, see Notes ``ext_rank`` : rank of the tensor counting the dummy indices ``rank`` : rank of the tensor ``coeff`` : SymPy coefficient of the tensor ``free_args`` : list of the free indices in sorted order ``is_canon_bp`` : ``True`` if the tensor in in canonical form Notes ===== ``args[0]`` list of ``TensorHead`` of the component tensors. ``args[1]`` list of ``(ind, ipos, icomp)`` where ``ind`` is a free index, ``ipos`` is the slot position of ``ind`` in the ``icomp``-th component tensor. ``args[2]`` list of tuples representing dummy indices. ``(ipos1, ipos2, icomp1, icomp2)`` indicates that the contravariant dummy index is the ``ipos1``-th slot position in the ``icomp1``-th component tensor; the corresponding covariant index is in the ``ipos2`` slot position in the ``icomp2``-th component tensor. r>rnc URSS5n[[[U55nUVs/sHn[ U5PM nn[ [ R"U65n/nUHn[ [U55nUVs/sHn[U5PM n n[ [ R"U 65n [ [ U55n [URU55S:a'U RXY5n [RXK5n OUn URU 5 M UnUVV s/sH6n[U[[ 45(a UR"OU/HoPM M8 nnn [R%USS9upp_UV s/sHoR&PM nn [)X_UXS9n[*R,"U/UQ76nUUlUR15UlUUlUR6SSUlUR:SSUlUR6Vs1sHnUSiM snUl[UR65Ul [UR4R65S[UR4R:5--Ul![DRFUl$UUl%U$s snfs snfs sn nfs sn fs snf)NrFr)replace_indicesrRrA)&rrr3r!rrbr#r$get_dummy_indicesrN intersectionunionr_dedupe_indicesrjrrrrrWr>rr_indicesr~ _index_typesrnrJrrKr _free_indices_rankrOrrr _is_canon_bp)rrr4rr*rJrddum_thisr dum_other free_thisexcludenewargrYrMrKrLr rrEs r4rTensMul.__new__m sokk-7 C$'( 266# %69??D)*C,S12H7>?w!*1-wI?IOOY78I,S12I8((./!3#//$: 00> NN6 ""dTc 3RU8W8WCHH^a]b,ba,bTd#*#D#DT[`#D#a t5< s (9(9r3cUR$r]rrts r4rFr r3cUR$r]rrts r4rFr s r3cUR$r]rrts r4rFr s ););r3cUR$r])rrts r4rFr rr3cUR$r]rrts r4rFr sT^^r3c 0n0n/n/nSn[U5HupgUHn[U[5(d [S5eU*U;aqUR U*5n UR U*5n UR (aUR XXU 45 OUR U*XX45 UR U5 O,X;a[SU-5eXaU'XRU'UR U5 US- nM M [UR55n UR5V s/sHoRPM n n URSS9 XKX4$s sn f)Nrzexpected TensorIndexzRepeated index: %srec US$rr2rDs r4rF.TensMul._indices_to_free_dum.. sadr3rH) rfrryr3rrhrjrirr6rrgrP)r free2pos1 free2pos2 dummy_datarMr}r| arg_indicesrm other_pos1 other_pos2rJrY free_namess r4_indices_to_free_dumTensMul._indices_to_free_dum sG   !*[TU5nTU==S- ss'URS-U-$rrrs r4r9TensMul._tensMul_contract_indices..dummy_name_gen rr3rA) rurrr rrWrIrr rrrr)rrr replacementsr*rrMrJrrr old_indexpos1cov pos1contrapos2cov pos2contrar;rrrrKrs @r4r!TensMul._tensMul_contract_indices s$()DqD )599DS C(D 9070L0L\0Z-z# ; GQC J&88 !/ !;J!3"z:S qr@RS38 %i08=v ()4#( ',f#HR"%T!8:!8IC/9h.G.G$$T*SP!8 : 9==K,L=4;4P4PQ]4^ 1G:((4dC''M*:,:>s EE!5E&E,c/nUHLn[U[5(dM[U[5(aM1URUR5 MN U$)zY Get a list of ``Tensor`` objects having the same ``TIDS`` if multiplied by one another. )rrrr^r`)rr`r*s r4_get_components_from_args!TensMul._get_components_from_argssM  Cc8,,#w''   cnn -  r3cUR5nSn[U5HFupE[U[5(dMUnX5R- n[ UR X&U5X'MH grC)rurfrrrrra)rr rMind_posrYr*prev_poss r4_rebuild_tensors_listTensMul._rebuild_tensors_lists]!--/oFAc8,,H || #GS]]GW,EFDG &r3c URnURSS5nU(a{URVs/sHoDR"S0UD6PM nn[ [ URU55nUR U5nURVs/sHovUPM nnO URnUVs/sHoDUR:wdMUPM nn[SUVs/sHn[U[5(aMUPM sn[R5nUVs/sHn[U[5(dMUPM nn[U5S:XaU$XR:waU/U-nUS:Xa[R$[U5S:XaUS$[R!U5upYpU V s/sHoR"PM n n [%XXUS9nUR&"U6nXlXl[UR*R,5S[UR*R.5--UlXlX/lU$s snfs snfs snfs snfs snfs sn f) NrTc X-$r]r2rbs r4rFTensMul.doit..1sACr3rrerrAr2)rrrrrWr _dedupe_indices_in_ruleidentityrrrrrrNrMrrrWr>rIrrnrJrKrOr)rQrtrrr*rrulerr'rMrJrKrYrLr rs r4r TensMul.doits'' yy& 15;#HH%u%D;  DIIt,-D//5D%)YY/YGYD/D99D#L MM !7T>D A:66M t9>7N#*#D#DT#J t5<rbrurfrr) r`rJrKr rMrYtensorsrrars r4r-TensMul._get_tensors_from_components_free_dumSs *BB:UXY!--/!+,A4,%j1LAH ~~ %G 8+DEGJ2-s A0cJURVs1sHoSiM sn$s snfrCr+rs r4rTensMul._get_free_indices_setds "ii(i!i(((s c[[R"UR65n[ UR R 55VVs1sHup#X!;dM UiM snn$s snnfr])rbr#r$rKrfrnrur%s r4rTensMul._get_dummy_indices_setgsO 23 "+D,A,A,M,M,O"Pc"PTUTb"Pcccs A&A&c[UR5Vs/sHnSPM nnSnURHJn[U[5(dM[UR5H nX2XS-'M X4R- nML U$s snfrC)rrrrr)rQrY arg_offsetcounterr*rs r4 _get_position_offset_for_indices(TensMul._get_position_offset_for_indicesksz$)$--$89$8qd$8 999Cc8,,3<<(*11;') || #G  :s Bc\[URVs/sHoSPM sn5$s snfrCrrfs r4r!TensMul.free_argsvr5r6c8URUR5$r])rrrts r4r`TensMul.componentszs--dii88r3cUR5nUR5nURVVs/sHup4X4X- X$4PM snn$s snnfr])r_get_indices_to_args_posrJ)rQrargposrrqs r4r,TensMul.free_in_args~sJ::< ..0JN))T)JS*/)6;7)TTTsA cUR$r]rrts r4r' TensMul.coeffs{{r3crUR"/URQSUR- P76RSS9$NreFr)rIrr'rrts r4rTensMul.nocoeffs3yy2$))2Qtzz\277U7CCr3c UR5nUR5nURVVs/sHup4X1U- XAU- X#X$4PM snn$s snnfr])rrrK)rQrrr/r0s r4r1TensMul.dum_in_argss]::< ..0]a]e]ef]eSYSUrN"B"~$5vz6:N]efffs AcUS:XaURS:H$[U5n[U[5(d"UR(aeURU:H$UR 5UR 5:H$rC)r'r!rrr`rRrs r4rTensMul.equalssa A:::? "%** &&::& &}}%.."222r3cUR$)a Returns the list of indices of the tensor. Explanation =========== The indices are listed in the order in which they appear in the component tensors. The dummy indices are given a name which does not collide with the names of the free indices. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensor_heads('p,q', [Lorentz]) >>> t = p(m1)*g(m0,m2) >>> t.get_indices() [m1, m0, m2] >>> t2 = p(m1)*g(-m1, m2) >>> t2.get_indices() [L_0, -L_0, m2] )rrts r4ruTensMul.get_indicess6}}r3c6URR5$)a) Returns the list of free indices of the tensor. Explanation =========== The indices are listed in the order in which they appear in the component tensors. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensor_heads('p,q', [Lorentz]) >>> t = p(m1)*g(m0,m2) >>> t.get_free_indices() [m1, m0, m2] >>> t2 = p(m1)*g(-m1, m2) >>> t2.get_free_indices() [m2] rHrts r4rTensMul.get_free_indicess2$$5577r3c UR"URVs/sH+n[U[5(aUR U5OUPM- sn6$s snfr])rIrrrr)rQrr*s r4rTensMul._replace_indicessJyygkgpgpqgp`cC9R9R3//5X[pqrrqs2AcURS:XaU/$/nSnURH3n[U[5(aURX#-5 SnM/X#-nM5 U$)am Returns a list of tensors, whose product is ``self``. Explanation =========== Dummy indices contracted among different tensor components become free indices with the same name as the one used to represent the dummy indices. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads, TensorSymmetry >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> a, b, c, d = tensor_indices('a,b,c,d', Lorentz) >>> A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2)) >>> t = A(a,b)*B(-b,c) >>> t A(a, L_0)*B(-L_0, c) >>> t.split() [A(a, L_0), B(-L_0, c)] r2re)rrrrj)rQsplitprr*s r4r TensMul.splits\0 99?6M99C#v&& cg&    r3c URVs/sH-n[U[[45(a UROU4PM/ nn[[R "U6Vs/sHn[ U6RSS9PM sn6$s snfs snfr)rrrrr#productrr)rQrtr*args1rYs r4_eval_expand_mulTensMul._eval_expand_mulsTXT]T]^T]SZc7^<<3&HT]^2;2C2CU2KM2KQGQK  %  (2KM  _Ms 4BBc`[[RXRS9R SS9$)NrFr)rrrrrrts r4r(TensMul.__neg__s(q}}d8I8IJOOUZO[[r3c[5 [[5 URUsSSS5 $!,(df  g=fr]rrs r4rTensMul.__getitem__rrc[UR5nURR5(a.SnUS[R :XaUSSnX!4$US*US'X!4$SnX!4$)Nrrrer)rrr'could_extract_minus_signrr)rQrr`s r4!_get_args_for_traditional_printer)TensMul._get_args_for_traditional_printer svDII :: . . 0 0DAw!--'ABx z 7(QzDzr3c URVs/sHn[U[5(dMUPM nnSn[U5S- n[ U5Hn[ XES5HnX&S- R X&5nUS;aM#[ [X&S- RR5SS9n[ [X&RR5SS9n XUS- RR4XURR4:dMX&X&S- sX&S- 'X&'U(dMU*nM M X0R-n U S:waU /U-$U$s snf)z Returns the ``args`` sorted according to the components commutation properties. Explanation =========== The sorting is done taking into account the commutation group of the component tensors. rerrcUR$r]rrDs r4rF:TensMul._sort_args_for_sorted_components..+s PQPVPVr3rHcUR$r]rrDs r4rFr",saffr3) rrrrNrrrrbrarLrgr') rQr*cvr`rkrYrrr~typ2r's r4 _sort_args_for_sorted_components(TensMul._sort_args_for_sorted_componentss<"YY DYc*S(*CcY D GaKqA1_sG))"%0F?c"qS'"3"3"?"?@FVWc"%//"="=>DTUQqS'++001Ta5??;O;O4PP%'UBsGNBsGRUq $u%zz! A:7R<  )Es EEcH[UR56RSS9$)z2 Returns a tensor product with sorted components. Fr)rr&rrts r4rCTensMul.sorted_components8s&==?@EE5EQQr3Fc[XUS9$) Returns the tensor corresponding to the permutation ``g`` For further details, see the method in ``TIDS`` with the same name. rr:r;s r4rTensMul.perm2tensor>s 4 <>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead, TensorSymmetry >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(-2)) >>> t = A(m0,-m1)*A(m1,-m0) >>> t.canon_bp() -A(L_0, L_1)*A(-L_0, -L_1) >>> t = A(m0,-m1)*A(m1,-m2)*A(m2,-m0) >>> t.canon_bp() 0 FrrT)rrrrrRr`rrCrnrrrrrMr) rQr rrrrrr>tmuls r4rRTensMul.canon_bpFs&   K{{} dG $ $==? "Kyyey$  " " $--@@BD !!,, /1t0a0 !866M}}S$' r3c(URU5nU$r]r)rQrrs r4rTensMul.contract_deltajs   'r3c0nSn[UR5HXup4[U[5(dM[U[5(de[ UR 5H nX1U'US- nM MZ U$)zE Get a dict mapping the index position to TensMul's argument number. rre)rfrrrrrr)rQpos_map pos_counterarg_ir*rYs r4r TensMul._get_indices_to_args_posnsr #DII.JEc8,,c6** **3<<(', $q ) /r3c  UR5RSS9nX:wa[U5n[X!5$UR 5n[ UR 5nUR[RS5:XaSnORUR[RS5:XaSnO,UR[RS5:XaSnO[e[UR 5VVs/sH0upg[U[5(dMURU:XdM.UPM2 nnnU(dU$Sn UR SSn UR"SSn [%5n UGHEn X;aM U Vs/sHosUSU :XdMUPM nnU Vs/sHosUSU :Xd X7SU :XdMUPM nnU(dM]U R'U 5 SXM'[)U5S:XaU(dHUunnUUSU :XaUSnOUSnUUSU :XaUSnOUSnU R+UU45 GOCUunnUUSU :XaUSnUSS:XaU *n OUSnUSS:XaU *n UUSU :Xa USnU *n OUSnU R+UU45 O[)U5S:XaU(d]USunnUUUU:XaUR,SnU UR.-n OUUU :XaUnOUnUSunnU R+UU45 OnUSunnUUUU:Xa(UR,SnU UR.-n UU:aU *n O2UUU :Xa UnUS:XaU *n OUnUSunnU R+UU45 U Vs/sH owU;dM UPM n nU Vs/sH owU;dM UPM n nGMH SnS/[)U5-n[1[)U55HnXl;aUS- nMUUU'M U VVs/sHunnUUU ;dMUUUUU- 4PM n nnU VVs/sH2unnUUU ;dMUUU ;dMUUUU- UUUU- 4PM4 n nnU [3U6-RSS9n[U[45(dU$[6R9UR:X5nUR=U5$s snnfs snfs snfs snfs snfs snnfs snnf)aA Raise or lower indices with the metric ``g``. Parameters ========== g : metric Notes ===== See the ``TensorIndexType`` docstring for the contraction conventions. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensor_heads('p,q', [Lorentz]) >>> t = p(m0)*q(m1)*g(-m0, -m1) >>> t.canon_bp() metric(L_0, L_1)*p(-L_0)*q(-L_1) >>> t.contract_metric(g).canon_bp() p(L_0)*q(-L_0) FrrrerArN)rrrRrrrrrrrrrPrfrrrarKrJrbrXrNrjrLrUrrrr>rbr`r)rQrr r3rrrYrEgposr`rKrJelimgposxfree1rzdum10dum11p0r/rrrnrr shiftshiftsrrs r4rTensMul.contract_metric}s;8{{}!!u!- <D>D"4+ +//1DII ::77; ;G ZZ>99!< <G ZZ>55a8 8G% %( 2a2dajF6KPQP[P[_`P`2aKhhqkyy|uE} $?1! (>QE?"Ws!admu&<! QV@VAsDW HHUODK4yA~#'LE5uQx(E1"1X#1XuQx(E1"1X#1XJJBx(#'LE5uQx(E1"1X 8q=$(5D#1X 8q=$(5DuQx(E1"1X $u#1XJJBx(Ta#AwHCs|ws|3mmA.#CGG|#3<50!$B!$B!&qQ S"I.#AwHCs|ws|3mmA.#CGG|9$(5D#3<50!$B"ax(,u!$B!&qQ S"I.!3cd]1cC3#6t!~AtD6DsxSYs4y!Ay F1I " ?C]d(3gajX\F\-a&,,-d]RUNRUBY`acYdlpYpCu|}vAIMvMCVGBK(("vgbk/B*BCRUNWd^#***6#x((J  5 5cnnd P++B//ib@Wh46^Ns`.R2 R2R2,R8?R8 R=)R=4 SS SS)S =S S*S5ScFUR5nUR"USU06$rrrs r4r TensMul._set_new_index_structure!rr3rcv[U5UR:wa [S5e[UR5nSn[ U5HXupg[ U[5(dM[ U[5(deURnUR"X%XX-6XF'XX- nMZ [USU06RSS9$)NrrrFr) rNrrirrrfrrrrrr) rQrrMr4rrqrYr*rs r4rTensMul._set_indices%s w<4== (67 7DIIoFAc8,,c6** **||H&&CL(ABDG OC &6+6;;;GGr3crUH1n[U[5(dM[U[5(aM1e gr])rrr)rrJrKr*s r4&_index_replacement_for_contract_metric.TensMul._index_replacement_for_contract_metric3s/Cc8,,c6** **r3c/nURH8n[U[5(aUR"U6nUR U5 M: [ U6R SS9$r)rrrrrjrrrs r4rTensMul.substitute_indices:rr3c[5 URn[U5nUVs/sHo3RPM snUVs/sHo3RPM sn:wa [ S5eX:XaU$UR "[[ X!556n[UVs1sHoUR(aUOU*iM sn5[U5:waUR"UR6$U$s snfs snfs snfrorprqs r4rTensMul.__call__Brsrtc Z[URVs/sH+n[U[5(dMUR U5PM- sn6up4[ [ RURVs/sHn[U[5(aMUPM sn[R5n[RU5upxp[RU 5n URn URSS9 UV s/sHoSPM nn X[R!XKU 5-4$s snfs snfs sn f)Nc US$rr2rDs r4rF'TensMul._extract_data..Xs!r3rHr)r rrrr7roperatormulrrrrrrrPrr)rQr&r*rr5rr'rMrJrrrKrrYras r4r7TensMul._extract_dataRs"TXT]T]${T]Sakloqyaz%HS%6%67G%HT]${| x||%ZA*QPXBYa%Z\]\a\ab070L0L\0Z-z((4== n %&*+d!d +#;#M#Mf[c#dddd%|%Z ,sDD.D# D# 4D(c[5 [[5 [UR 5nSSS5 U$!,(df  W$=fr]r)rQrs r4r TensMul.data\s9 4 50?C6 6 5 s < A c,[5 [S5e)Nz9Not possible to set component data to a tensor expressionr5rirs r4rrTcsTUUr3c,[5 [S5e)NzrxrrWrIrr) rrdums_newfree_new conflictsrYexclude_for_genr]rdnewnamenew_d new_renameds r4rTensMul._dedupe_indicestsg,(-.',-))'2 y>Q  x x .56gt9g6>>OArTYY[ !--.GFF70QVVABZ0EGvDH  t9>**40 7s< D!cUR5VVs0sHup#[U[5(dMX#_M nnnUR5VVs0sHup#X$R5;dMX#_M nnn[ UR 55n0nUR U5 UR UR55 UR UR55 UR5HFup[RX5n X:XdU cXU'M(XU'UR [ U 55 MH U$s snnfs snnf)zJ rule: dict This applies TensMul._dedupe_indices on all values of rule. ) r6rryrrbrurvaluesrr) rQrr8r index_rules other_rulesrnewrulerrrbs r4rTensMul._dedupe_indices_in_rules'+jjlQlsqjK6Psqsl Q&*jjlRlsqa?O?O?Q6Qsqsl Rd&&(){#{'')*{))+,#))+HC!11#?Kz[0" * {;78 ,RRsD;D;E,Ec[U[5(dgU1nURX5nUcgURX5R SS9$)zh If new is an index which is already present in self as a dummy, the dummies in self should be renamed. NFr)rryr_subsr)rQrrr self_renameds r4 _eval_subsTensMul._eval_subssS #{++%++D:  %%c/44%4@ @r3c*SSKJn UR5Vs/sHoDRSPM nnUVs/sH$n[ Xc5(aURSOUPM& nn[ R "U5nURXu5$s snfs snf)NrrA)rCrBrurrrrrF)rQrrrBrYrDr*r s r4r TensMul._eval_rewrite_as_Indexeds}1,0,<,<,>?,>q,> ?HLMz#33 <M||D!""477@Ms B +Bc /n[UR5Hup4[U[5(aUR U5nO3UR (aUR U5nO[RnU(dMhUR[RURSUU4-URUS-S-5RSS95 M [RU5RSS9$r)rfrrrrrrrrMrjrrrr)rQr termsrYr*r_s r4r TensMul._eval_partial_derivatives *FA#x((003;;,,Q/AAq W--diimqd.BTYYqSTuvEV.VW\\bg\hi+&+++77r3Nc \ ^$^%[U[5(d([U[[45(a [U5nOgUc0nO^UR 5nUR 5Vs/sHn[U[ 5(dMUPM snm%U%4SjnU"U5nU"U5n[SURVs/sHn[U[5(aMUPM sn[R5nX:XaU$[[U55S:XaURXU5$Sn[URU5n [URU5n SU R5;a7[U S6R!SS9UR":wa[%S U S35eSU R5;a-[U S6R!SS9U:wa[%S U S35eU S V s1sHn ['[)U S /55iM n n U S V s1sHn ['[)U S /55iM n n U R+U 5(dg[U S 5S:GaU S SnUR-5GHxnU S GHjn[U[5(aS nOS nUU-R/U5nUcM8UR0"U/URVs/sH nUU:wdM UPM snQ76R!SS9nUR0"URVs/sH nUU:wdM UPM sn6R!SS9n0nUR3U5 UR3U5 UR5UUS9nUcMSnUR5HCn[U[ 5(dMU*UR5;dM1UU*UU*:wdMASn O U(dGMVUR3U5 Us s $ GM{ g/nU S n[U SSSS9unnUHn[7UR955n/nUHVn U R95n!Sn"U!H!m$[;U$4SjU55(dMSn"M# U"(dMEUR=U 5 MX UR5[U6R!SS95nUc gUHn#UR=U#5 M UR3U5 M U S V s/sH n U U;dM U PM nn [U5S:aAUSR5[S /UQ76R!SS95nUcgUR3U5 O[U5S:agUR"R5XsS9nUcgUR3U5 U$s snfs snfs sn fs sn fs snfs snfs sn f)z Match assuming all tensors commute. But note that we are not assuming anything about their symmetry under index permutations. Nc>>[RUT5nUbU$U$r])rr)r renamedrMs r4dedupe,TensMul._matches_commutative..dedupes%!11$@&"NKr3c X-$r]r2rs r4rF.TensMul._matches_commutative..sr3rch[U[5(ag[U[[45(agg)Nrrr')rrrr)r*s r4r-TensMul._matches_commutative..siftkey s*#z**#C&(!344r3r'Frz/Found something that we do not know to handle: rr`rre)rOTrc:[UR55S:H$rC)rNrrDs r4rFrzNsCPQPbPbPdLeijLjr3)binaryc3H># UHoRT5SLv M g7fr])r)rrrYs r4r/TensMul._matches_commutative..WsHA99Q<4/s"re)rrrrr~reryrrrrrNrrPr*rrr'rPrgetattrissubsetrbrfrIrrrbrrrj)&rQr rOrr8rwr* expr_coeffrrrrEquery_tens_headsexpr_tens_headsrq_tensrr`rgr rem_queryrem_exprtmp_replrem_minternally_consistentrrindexless_wildswildsrfree_this_wildtensors_to_tryrrJshares_indices_with_wildrJrYrMs& @@r4_matches_commutativeTensMul._matches_commutatives $(($4 011t}  I!(I#,"2"2"4S"4Q 1k8Rq"4SG $*L),[\gho\p[q*rssIUV^I_`I_AE'!\2">?I_`HST\H]^H]15L"!=>H]^((99 |H% & *#H-a0H #99;$X.A!&'22! f..q1Ay $ $ YTYY1XY!x-!Y1X Y ^ ^di ^ jI#yydii*Ji161i*JKPPV[P\H!HOOI.OOA&%--h(-KE(04-!&A)!K88$%2#5%)ay:P277U7CEAy*D%,,T2+  #',+6h*?^*?Q1L]C]q*?^  ! # #++WQ-L8K-L-Q-QW\-Q-]_Ay  # $ % ) JJ  z  3 9   Q KT/j8a^42Y*J\_sH(V V 9V V % V V VV V$ V$ % V)3V)c[U5nUc0nOUR5n[SUR55nU(aUR XU5$[ S5e)Nc3# UH5n[U[5(dMURRS:Hv M7 g7fr)rrrar)rr*s r4r"TensMul.matches..s-^#jQTV\F]-cmm((A-s? ?z9Tensor matching not implemented for non-commuting tensors)rr~rrrrP)rQr rOrcommutes r4rTensMul.matcheszsXt}  I!(I^^^ ,,TcB B%&ab br3r2r*rrRrrS)ErrrrrrrrrrrrLrJrKrarrrrrrrrrrrrrrr!r`r,r'rr1rrurrrrr(rrr&rCrrRrrrrrrGrrr7rrrrrrrmrrrrrr2r3r4rrB s%LuuH%%-^9:K + ,D ) *C;>> from sympy.tensor.tensor import TensorIndexType, TensorHead, TensorSymmetry >>> from sympy import symbols >>> L = TensorIndexType("L") >>> i, j, k = symbols("i j k") >>> A = TensorHead("A", [L, L], TensorSymmetry.fully_symmetric(2)) >>> A(i, j).get_free_indices() [i, j] If we want to set component ``i`` to a specific value, use the ``TensorElement`` class: >>> from sympy.tensor.tensor import TensorElement >>> te = TensorElement(A(i, j), {i: 2}) As index ``i`` has been accessed (``{i: 2}`` is the evaluation of its 3rd element), the free indices will only contain ``j``: >>> te.get_free_indices() [j] c [U[5(dV[U[5(d[SU-5eUR"UR Vs/sHn[ X25PM sn6$UR5nUVs0sHoUR SU_M nnUR5VVs0sHupxURXw5U_M nnnUR5VVs0sHupxXt;dM Xx_M nnn[U5S:XaU$UVs/sHoUUR5;dMUPM n n[U5n[RXU5n XlU $s snfs snfs snnfs snnfs snf)Nz%s is not a tensor expressionr)rrrr3rIrrrr6rrNrrrr) rr r r*expr_free_indicesrYname_translationrmrWrars r4rTensorElement.__new__sL$''dH-- ?$ FGG99 R }S< RS S 1132CD2CQFF1IqL2CDS\SbSbSdeSd<5%))%7>Sd e6?oo6Gf6Gle5Ke\U\6G f y>Q K#4R#4aAQ8Q#4 RO s)4( SDefSs*EE .E%" E+1E+E1*E1cl[UR55VVs/sHupX!4PM snn$s snnfr])rfr)rQrYrms r4rJTensorElement.frees.+4T5J5J5L+MN+Mxq +MNNNs0c/$r]r2rts r4rKTensorElement.dums  r3c URS$rC_argsrts r4r TensorElement.exprzz!}r3c URS$rrrts r4r TensorElement.index_maprr3c"[R$r]rZrts r4r'TensorElement.coeffr\r3cU$r]r2rts r4rTensorElement.nocoeffr_r3cUR$r]rrts r4rTensorElement.get_free_indicess!!!r3c$URU5$r]rKrs r4rTensorElement._replace_indicess}}T""r3c"UR5$r])rrts r4ruTensorElement.get_indicess$$&&r3c^URRU5up#URm[U4SjU55nUVs/sH oUT;dM UPM nnUR U5nX#4$s snf)Nc3Z># UH nTRU[S55v M" g7fr])rslice)rrYr s r4r.TensorElement._extract_data..s#O;aIMM!U4[99;s(+)r r7r rr)rQr&r<r slice_tuplerYr s @r4r7TensorElement._extract_datasl!YY445EF NN O;OO "-D+Q)1Cq+ D!!+.!!Es  A-A-r2NrR)rrrrrrrrJrKr r r'rrrrur7rr2r3r4rrs6$OO"#'"r3rc8\rSrSrSrSSjr\S5rSrSr g) WildTensorHeadia  A wild object that is used to create ``WildTensor`` instances Explanation =========== Examples ======== >>> from sympy.tensor.tensor import TensorHead, TensorIndex, WildTensorHead, TensorIndexType >>> R3 = TensorIndexType('R3', dim=3) >>> p = TensorIndex('p', R3) >>> q = TensorIndex('q', R3) A WildTensorHead can be created without specifying a ``TensorIndexType`` >>> W = WildTensorHead("W") Calling it with a ``TensorIndex`` creates a ``WildTensor`` instance. >>> type(W(p)) The ``TensorIndexType`` is automatically detected from the index that is passed >>> W(p).component W(R3) Calling it with no indices returns an object that can match tensors with any number of indices. >>> K = TensorHead('K', [R3]) >>> Q = TensorHead('Q', [R3, R3]) >>> W().matches(K(p)) {W: K(p)} >>> W().matches(Q(p,q)) {W: Q(p, q)} If you want to ignore the order of indices while matching, pass ``unordered_indices=True``. >>> U = WildTensorHead("U", unordered_indices=True) >>> W(p,q).matches(Q(q,p)) >>> U(p,q).matches(Q(q,p)) {U(R3,R3): _WildTensExpr(Q(q, p))} Parameters ========== name : name of the tensor unordered_indices : whether the order of the indices matters for matching (default: False) See also ======== ``WildTensor`` ``TensorHead`` Nc [U[5(a [U5nO#[U[5(aUnO [S5eUc/nUc[R [ U55nOUR[ U5:XdeU[R [ U55:wa [S5e[R"X[U6[U5[U5[U55nU$)Nrz3Wild matching based on symmetry is not implemented.) rrrrirrrNrrPrrrr)rrgrLrrunordered_indicesrrs r4rWildTensorHead.__new__s dC  ,K f % %K^, ,  K  %11#k2BCH==C $44 44 ~11#k2BC C%&[\ \mmCe[.A78CTV]^bVcelm~eA r3c URS$)Nr,rrts r4r WildTensorHead.unordered_indices1rr3c:[X40UD6nUR5$r])rr)rQrMrr?s r4rWildTensorHead.__call__5sD4V4{{}r3r2)NNrF) rrrrrrrrrrr2r3r4rrs&6n.r3rc2\rSrSrSrSrSSjrSSjrSrg) ri:a0 A wild object which matches ``Tensor`` instances Explanation =========== This is instantiated by attaching indices to a ``WildTensorHead`` instance. Examples ======== >>> from sympy.tensor.tensor import TensorHead, TensorIndex, WildTensorHead, TensorIndexType >>> W = WildTensorHead("W") >>> R3 = TensorIndexType('R3', dim=3) >>> p = TensorIndex('p', R3) >>> q = TensorIndex('q', R3) >>> K = TensorHead('K', [R3]) >>> Q = TensorHead('Q', [R3, R3]) Matching also takes the indices into account >>> W(p).matches(K(p)) {W(R3): _WildTensExpr(K(p))} >>> W(p).matches(K(q)) >>> W(p).matches(K(-p)) If you want to match objects with any number of indices, just use a ``WildTensor`` with no indices. >>> W().matches(K(p)) {W: K(p)} >>> W().matches(Q(p,q)) {W: Q(p, q)} See Also ======== ``WildTensorHead`` ``Tensor`` c URSS5nUR[:Xa[X4SU0UD6$UR[:XaU"U6$UR X5nUVs/sHoUR PM nnURURUSURURS9n[R"X[U65nURUl[R"U6UlURR SSUlURR$SSUlURR(Ul[*R,UlXwlXlU/UlUR6[9U5:wa [;S5eXGlUR?X'R5Ul U$s snf)NrF)rrrr)!rrIrr _WildTensExprrrWrgrrrrrr>rZrnrJrrKrrOrrrrrrrrNrirrr)rrrMr4rrrLrs r4rWildTensor.__new__^skk-7   z ) +SKS7S S    .( ($$[:8?@,, @!&&    !!);; ' mmCeWo>##.;;WE((--a0 ''++A.,,66 UU  $&-   s7| +67 7%--g7K7KL 1As$F>Nc[U[5(dU[S5:wagUc0nOUR5n[ UR 5S:a[ US5(dgUR5n[ U5[ UR 5:wagURR(a'URU5nUcgURU5 OQ[[ U55H9nUR URXF5nUc gURU5 M; [U5X R'U$XU'U$)Nrerr)rrrr~rNrMrrrr_match_indices_ignoring_orderrrrrra)rQr rOr expr_indicesrgrYs r4rWildTensor.matchess$))dadl  I!(I t|| q 4!344002L< C $550066t<9$$Q's<01A Q// @Ay#!((+ 2)6d(;Inn % #dOr3cUc0nOUR5nSn[URU5n/nUR5nUSHXnSn UHDn X;aM UR U 5n U cM Sn UR U 5 UR U 5 O U (aMX g UV s/sH oU;dM U PM nn USHunSn UHan UR U 5n U cMU*UR5;aX(**X:wa gSn UR U 5 UR U 5 O U (aMu g UV s/sH oU;dM U PM nn USHunSn UHan UR U 5n U cMU*UR5;aX(**X:wa gSn UR U 5 UR U 5 O U (aMu g [U5[UR5:agU$s sn fs sn f)zf Helper method for matches. Checks if the indices of self and expr match disregarding index ordering. NcT[U[5(aUR(aggg)N wild, updownwildr)rWildTensorIndex ignore_updown)rs r4r9WildTensor._match_indices_ignoring_order..siftkeys!#//$$)! r3rFTrr) r~r*rMrurrrjrrN) rQr rOrrindices_siftedmatched_indicesexpr_indices_remainingrmatched_this_inde_indrgrYs r4r(WildTensor._match_indices_ignoring_orders+  I!(I !dllG4!%!1!1!3!),C$ /+KK&='+$$$Q'#**510$#-.D!`-CP_G_!-C!`!&)C$ /KK&=ty~~//Yt_4D4N#'+$$$Q'#**510$#*.D!`-CP_G_!-C!`!.1C$ /KK&=ty~~//Yt_4D4N#'+$$$Q'#**510$#2  #dll"3 3 C"a"as' G64G6> G; G;r2rS) rrrrrrrrrr2r3r4rr:s"F$N"HFr3rcB\rSrSrSrS Sjr\S5rSrS Sjr Sr g) ria A wild object that matches TensorIndex instances. Examples ======== >>> from sympy.tensor.tensor import TensorIndex, TensorIndexType, WildTensorIndex >>> R3 = TensorIndexType('R3', dim=3) >>> p = TensorIndex("p", R3) By default, covariant indices only match with covariant indices (and similarly for contravariant) >>> q = WildTensorIndex("q", R3) >>> (q).matches(p) {q: p} >>> (q).matches(-p) If you want matching to ignore whether the index is co/contra-variant, set ignore_updown=True >>> r = WildTensorIndex("r", R3, ignore_updown=True) >>> (r).matches(-p) {r: -p} >>> (r).matches(p) {r: p} Parameters ========== name : name of the index (string), or ``True`` if you want it to be automatically assigned tensor_index_type : ``TensorIndexType`` of the index is_up : flag for contravariant index (is_up=True by default) ignore_updown : bool, Whether this should match both co- and contra-variant indices (default:False) c[U[5(a [U5nOs[U[5(aUnO[USLaKSR[ UR 55n[U5nUR R U5 O [S5e[U5n[U5n[R"XX#U5$rr)rrgrWrhrrs r4rWildTensorIndex.__new__s dC  ,K f % %K T\==%6%E%E!FGD ,K  , , 3 3K @^, , . }}S/@WWr3c URS$rrrts r4rWildTensorIndex.ignore_updown%rr3c|[URURUR(+UR5nU$r])rrgrWrhrr&s r4r(WildTensorIndex.__neg__)s0 TYY(>(>ZZ$"4"46 r3Nc[U[5(dgURUR:wagUR(dURUR:wagUc0nOUR 5nXU'U$r])rryrWrrhr~rNs r4rWildTensorIndex.matches.si$ ,,  ! !T%;%; ;!!zzTZZ'  I!(I$r3r2)TFrS) rrrrrrrrr(rrr2r3r4rrs,"FX  r3rcl\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrg)ri@aD INTERNAL USE ONLY This is an object that helps with replacement of WildTensors in expressions. When this object is set as the tensor_head of a WildTensor, it replaces the WildTensor by a TensExpr (passed when initializing this object). Examples ======== >>> from sympy.tensor.tensor import WildTensorHead, TensorIndex, TensorHead, TensorIndexType >>> W = WildTensorHead("W") >>> R3 = TensorIndexType('R3', dim=3) >>> p = TensorIndex('p', R3) >>> q = TensorIndex('q', R3) >>> K = TensorHead('K', [R3]) >>> print( ( K(p) ).replace( W(p), W(q)*W(-q)*W(p) ) ) K(R_0)*K(-R_0)*K(p) cP[U[5(d [S5eXlg)Nz,_WildTensExpr expects a TensExpr as argument)rrr3r )rQr s r4rS_WildTensExpr.__init__Ts $))JK K r3cURR[[URR 5U555$r])r rrWr r)rQrMs r4r_WildTensExpr.__call__Ys1yy))$s4993M3M3OQX/Y*Z[[r3cZURUR[R-5$r])rIr rrrts r4r(_WildTensExpr.__neg__\syy1==011r3c[er]rrts r4r_WildTensExpr.__abs___rr3cURUR:wa%[SURSUR35eURURUR-5$Nz Cannot add z to rIr3r rs r4r_WildTensExpr.__add__bsN :: "k$))D EF Fyy5::-..r3cURUR:wa%[SURSUR35eURURUR-5$rrrs r4r_WildTensExpr.__radd__gsN :: "k$))D EF FyyDII-..r3c X*-$r]r2rs r4r_WildTensExpr.__sub__ls vr3c X*-$r]r2rs r4r_WildTensExpr.__rsub__os r3c[er]rrs r4r_WildTensExpr.__mul__rrr3c[er]rrs r4r_WildTensExpr.__rmul__urr3c[er]rrs r4r_WildTensExpr.__truediv__xrr3c[er]rrs r4r_WildTensExpr.__rtruediv__{rr3c[er]rrs r4r_WildTensExpr.__pow__~rr3c[er]rrs r4r_WildTensExpr.__rpow__rr3r N)rrrrrrSrr(rrrrrrrrrrrrr2r3r4rr@sN& \2"/ / """"""r3rcP[U[5(aUR5$U$)zh Butler-Portugal canonicalization. See ``tensor_can.py`` from the combinatorics module for the details. )rrrR)r s r4rRrRs" !Xzz| Hr3cU(d&[R[R///5$USnUSSHnX-nM U$)z product of tensors rreN)rrrr)rrtxs r4 tensor_mulrsG   B33 !Ae D Hr3c,[URSS9nUVs/sHo"SPM snup4pVU[SS5-nURX34XF4XT4Xe45*[SS5-nURX34XE4XT4Xf45[SS5-n Xx-U -n U $s snf)z{ replace Riemann tensor with an equivalent expression ``R(m,n,p,q) -> 2/3*R(m,n,p,q) - 1/3*R(m,q,n,p) + 1/3*R(m,p,n,q)`` c US$rr2rDs r4rF(riemann_cyclic_replace..s!A$r3rHrrArre)rrJr r) t_rrJrErgrkr qt0r't2t3s r4riemann_cyclic_replacer s #(( /D $%1A$%JA! Xa^ B !uaUA5 9 9(1a. HB  qeQE1% 8!Q GB 2B I &sBc UR5n[U[[45(aU/nO URnUVs/sHo"R 5PM nnUVVs/sHoDVs/sHn[ U5PM snPM nnnUVs/sH n[U6PM nn[U6RSS9n U (dU $[U 5$s snfs snfs snnfs snf)a Replace each Riemann tensor with an equivalent expression satisfying the cyclic identity. This trick is discussed in the reference guide to Cadabra. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead, riemann_cyclic, TensorSymmetry >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) >>> R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann()) >>> t = R(i,j,k,l)*(R(-i,-j,-k,-l) - 2*R(-i,-k,-j,-l)) >>> riemann_cyclic(t) 0 Fr) rrrrrrr rrrrR) r rrEa1rra2ra3r s r4riemann_cyclicrs$ B"w'((tww! "T'')TB "<> ?Bq 2" !" % 2BB ?"$ %"Q*a."B % "    &B  | # 2 ? %s$C  C)C >C CCcTSnURn0nURHn[U[5(dMXT;aM!URn/n[ [ U55HnXhULdM UR U5 M [ U5S:a[SU-5e[ U5S:XdMXtU'M /n /n /n URGHYuppX>U;aMX:XaU R U/5 M*XCUnXCUnU U;aM@URU 5URU 5:Xa[eXCUnU US:XaX4OX4unnU R5nU HnUSU:XabUSU:XaFUR[U55nU R U5 U R UUSUSU-5 OUR U5 O4USU:XdMyURSU5 O UR UU/5 UVs/sH nUU ;dM UPM n nU"U 5n GM\ /nU HnUHnUR U5 M M U HnUHnUR U5 M M [ [ U55Vs/sH nUU;dM UPM nnXU4$s snfs snf)z Returns ``(lines, traces, rest)`` for an index type, where ``lines`` is the list of list of positions of a matrix line, ``traces`` is the list of list of traced matrix lines, ``rest`` is the rest of the elements of the tensor. cSnU[U5:GaaXnUSnUSnSnU(Ga2Sn[US-[U55GH nU[U5:a OXSU:Xa0SnURXSS5 USnURU5 MPXSU:Xa5Sn[ XSS5U-X'XnXSnURU5 MXSU:Xa9SnUR[ XSS55 USnURU5 MXSU:XdMSnXSSU-X'XnUSnURU5 GM U(aGM2US- nU[U5:aGMaU$)NrrTFre)rNrr^rreversed)rrYrExendxstarthitrs r4 _join_linesget_lines.._join_liness #a&jAR5DqTFCq1uc!f-ACF{tAw$"ab* ua tAw&("'QR1A5D!"aa tBx4'"!$s)!45 ua tBx6)" tCRy1}D!"1a 9.#> FAI#a&jJr3rAz&at most two indices of type %s allowedrerrN)rrrrLrrNrjrir1rmrPr~mininsert)exr;r argumentsdtrrLrrYlinestracestraces1r>r/c0c1ta0ta1b0b1lines1linerkrErestrs r4 get_linesr+s'RI B WW!X&&  7 mm s;'(A~+ ) q6A:E RS S q6Q;qE E FG.. = "  8 MM2$  22 S=  99R=CIIbM ) & %23q6\"BDBx2~7b= 3t9-ANN4(MM$qr(T"1X"56KKOaB Ar" MM2r( #"7Fqaw&6F7E"K)L DA KKNA KKNS^, >,! A,D > $ 8 ?s J J  J%J%cN[U[5(dgUR5$Nr2)rrrrs r4rrCs! a " "   r3cN[U[5(dgUR5$r-)rrrur.s r4ruruIs a " " ==?r3c[U[5(dgUR5nUR5nUVs/sH o3U;dM UPM sn$s snfr-)rrrur)rr^rJrYs r4rrNsG a " " ==?D   D -t!}At -- -s AAc`[U[5(a UR$[////5$r])rrrnr>r.s r4roroUs,!X!!! 2r2r **r3c[U[5(a[R$[U[5(a UR $[U[ 5(a [S5eU$)Nz3no coefficient associated to this tensor expression)rrrrrr'rrir.s r4 get_coeffr3[sL!Vuu !Www!XNOO Hr3cR[U[5(aURU5$U$r])rrr)rrs r4rrds%!X  ## Hr3c[U[5(dU$[U[[45(aA[ U5R XS9nUR X2S9nUS[U5S- :waU*$U$[5e)r+rrre) rrrrrorrrNrP)rrrnimrs r4rris| a " " A( ) )!!$000L(((F R5CFQJ 4K  r3cN[U[5(dU$UR"U6$r])rrr)rrs r4rr{s% a " "   ..r3c f[UR[[[[ [ 55$r])ratomsrrrrrrs r4rrs  4z?N[ \\r3c^U4SjnU$)Nc>[[[[0Tn[ SUR 55(aU"UR 6$U$)Nc3B# UHn[U[5v M g7fr])rr)rrs r4r._postprocessor..s: 1z!X&& s)rrrrrr)r  tens_classrs r4_postprocessor)get_postprocessor.._postprocessors?7C1#6 : : : :tyy) )Kr3r2)rr?s` r4get_postprocessorrAs r3rrCr)kr __future__rtypingr functoolsrmathrabcrr collectionsr rPr#sympy.core.numbersr r rSr sympy.combinatorics.tensor_canrrrr sympy.corerrrrrrsympy.core.cachersympy.core.containersrrsympy.core.functionrsympy.core.sortingrsympy.core.symbolrrrsympy.core.sympifyr r!sympy.core.operationsr"sympy.external.gmpyr#sympy.matricesr$sympy.utilities.exceptionsr%r&r'sympy.utilities.decoratorr(r)sympy.utilities.iterablesr*r5r9r<r>rrrrrrHryr0rrVrXr;rrrrrrrrrrrrRrr rr+rrurror3rrrrrA"_constructor_postprocessor_mappingr2r3r4rXs>###2+4488(-,/334)*99C*   h)kh)V  &s{sj ":!;jjZ k6ek6\ Z%Zz:A9UA9H #: ?,?,B ;"6 ;_;_  ;_| #6 ,,0O5O5d ntSnb ihiX aKXaKJDchDcL"W"HW"tUZUpuunLkL^B"EB"J    Bup  .+    $/ ] c " #6((2r3