9\c@ sidZddlmZmZddlmZddlZddlZddlm Z m Z m Z ddl m Z mZmZmZddlmZmZmZmZmZmZddlmZmZmZmZdd lmZmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)ddl*m+Z+ddl,m-Z-ddl.Z.e!dddddddZ/de&fdYZ0dZ1de&fdYZ2e2Z3de4fdYZ5e5Z6defdYZ7d efd!YZ8d"Z9d#efd$YZ:d%Z;d&efd'YZ<e=d(d)Z>d*efd+YZ?d,Z@d-efd.YZAd/eAe)fd0YZBd1eAfd2YZCd3eAe)fd4YZDd5eAfd6YZEd7ZFd8ZGd9ZHd:ZId;ZJd<ZKd=ZLd>ZMd?ZNd@ZOePdAZQdBZRdCZSdS(Ds 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. i(tprint_functiontdivision(t defaultdictN(tRationaltprodtInteger(tget_symmetric_group_sgstbsgs_direct_productt canonicalizet riemann_bsgs(tBasictExprtsympifytAddtMultS(t string_typestreducetranget SYMPY_INTS(tTupletDict(t deprecated(tSymboltsymbols(t CantSympifyt_sympify(tAssocOp(teye(tSymPyDeprecationWarningt useinsteads.replace_with_arraystissuei;tdeprecated_since_versions1.4cC sdS(N((((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytdeprecate_data4st_IndexStructurecB seZdZedZedZedZedZdZ edZ edZ edZ d Z d Zd Zd Zd ZdZdZedZdZRS(s 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. cC sa||_||_||_||_t|jdt|j|_|jjdddS(NitkeycS s|dS(Ni((tx((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytIt(tfreetdumt index_typestindicestlent _ext_ranktsort(tselfR'R(R)R*tcanon_bp((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__init__Cs     #cG sYtj|\}}g|D]}|j^q}tj|||}t||||S(sh Create a new ``_IndexStructure`` object from a list of ``indices`` ``indices`` ``TensorIndex`` objects, the indices. Contractions are detected upon construction. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, _IndexStructure >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='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]) In case of many components the same indices have slightly different indexes: >>> _IndexStructure.from_indices(m0, m1, -m1, m3) _IndexStructure([(m0, 0), (m3, 3)], [(1, 2)], [Lorentz, Lorentz, Lorentz, Lorentz]) (R"t_free_dum_from_indicesttensor_index_typet_replace_dummy_names(R*R'R(tiR)((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt from_indicesKscC sOg}x|D]}|j|jq Wtj|||}t||||S(N(textendR)R"t*generate_indices_from_free_dum_index_types(t componentsR'R(R)t componentR*((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytfrom_components_free_dumgs  c G st|}|dkr/|ddfggfStgt|}i}g}xt|D] \}}|j}|j}|j} ||f|krK|||f\} } | r| rtd| |fqt|| >> from sympy.tensor.tensor import TensorIndexType, tensor_indices, _IndexStructure >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='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)]) iis2two equal contravariant indices in slots %d and %ds.two equal covariant indices in slots %d and %d( R+tTruet enumeratet_nameR2t_is_upt ValueErrortFalsetappendR-( R*tnR't index_dictR(R4tindextnamettyptcontrtis_contrtpos((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR1os8         5 cC s|jS(s_ Get a list of indices, creating new tensor indices to complete dummy indices. (R*(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt get_indicessc C sdgt|dt|}x|D]\}}|||c C s|jddg|D] }|^q}t|t|dt|ksXttj|}xY|D]Q\}}||j}||} t| |t||s cS s||S(N((R$R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%R&N(!t_substitutions_dictRt TensorHeadRKtTensorRrRJtis_upR9t_substitutions_dict_tensmultdata_from_tensortdata_contract_dumR(text_ranktTensMultargsR+R8tTensExprtdataRtalltanyR?tTensAddRAR'RRtzipR<t free_argsR(R.R#R4t signaturetsrcht array_listt tensmul_argst data_listtcoefft data_resulttfree_args_listtargR$tsum_listRRRt free_args_postaxes((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRsb  (  +,I.%%* %% cC sJddlm}m}m}tt||}||}|||S(Ni(t tensorproductttensorcontractiontMutableDenseNDimArray(RRRRtlisttmap(t ndarray_listR(RRRRtarraystprodarr((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs cC s5|dkrdS|j||j|j|jtS(s 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. N(RKt_correct_signature_from_indicesRJR'R(R;(R.Rttensmult tensorhead((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytdata_tensorhead_from_tensmuls  cC sA|j}|jdkrdS|j|j|j|j|jS(s This method corrects the components data to the right signature (covariant/contravariant) using the metric associated with each ``TensorIndexType``. N(R9RRKRRJR'R((R.ttensorR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs  cC snt|trtdnt|jdkrBtdn|jd}|j|||}||fS(Nscannot assign data to TensAddis6cannot assign data to TensMul with multiple componentsi(RRR?R+R8R(R.R#RRtnewdata((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_assign_data_to_tensor_exprs c C sLddlm}t|tr7|j}|jj}n[t|tre|j}|jdjj}n-t|t r|j j}|j jj}nx|D]}|||krd nd}|}|} t t |t t |} xVt |jdD]>} ||| }t| ||r:tdn|} qWqWdS(Ni(Riis'Component data symmetry structure error(RRRRRxtsymmetryRRR8tTensorIndexTypetmetricRRRtorderRR?( R.ttensRRRxRtgenert sign_changet data_swappedt last_datat permute_axesR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_check_permutations_on_data s(    !cC stj|}|j||t|ttfsO|j||\}}nt|trxt|j|j D]f\}}|j dkrt dj |n|jdkrqtn||jkrtt dqtqtWn||j|>> 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]] i(Riit__call__(RRRR+thasattr(RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs %(RRRtdictRRRRRRRRRRRRRRRRRR@RRRR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRhs,    P       t_TensorManagercB seeZdZdZdZedZdZdZdZ dZ dZ d Z RS( s 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. cC s|jdS(N(t _comm_init(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR0scC sgtdD] }i^q |_x6tdD](}d|jd|>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead, TensorManager >>> Lorentz = TensorIndexType('Lorentz') >>> i0,i1,i2,i3,i4 = tensor_indices('i0:5', Lorentz) >>> A = tensorhead('A', [Lorentz], [[1]]) >>> G = tensorhead('G', [Lorentz], [[1]], 'Gcomm') >>> GH = tensorhead('GH', [Lorentz], [[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) iis+`c` can assume only the values 0, 1 or NoneN(iiN(RKR?RR+RRAR(R.R4RztcRBtnitnj((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytset_comms(2     cG s1x*|D]"\}}}|j|||qWdS(s set the commutation group numbers ``c`` for symbols ``i, j`` Parameters ========== args : sequence of ``(i, j, c)`` N(R(R.RR4RzR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt set_commsZs cC s5|j|j||dks(|dkr.dndS(s Return the commutation parameter for commutation group numbers ``i, j`` see ``_TensorManager.set_comm`` iN(RtgetRK(R.R4Rz((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRfscC s|jdS(s* Clear the TensorManager. N(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytclearns( RRRR0RtpropertyRRRRRRR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs     H RcB sjeZdZeddddZeedddddddZeeddddddd Z eeddddddd Z ed Z e j d Z e j d Z dZedZedZedZedZedZedZdZdZdZdZeZdZRS(sc A TensorIndexType is characterized by its name and its metric. Parameters ========== name : name of the tensor type metric : metric symmetry or metric object or ``None`` dim : dimension, it can be a symbol or an integer or ``None`` eps_dim : dimension of the epsilon tensor dummy_fmt : name of the head of dummy indices Attributes ========== ``name`` ``metric_name`` : it is 'metric' or metric.name ``metric_antisym`` ``metric`` : the metric tensor ``delta`` : ``Kronecker delta`` ``epsilon`` : the ``Levi-Civita epsilon`` tensor ``dim`` ``eps_dim`` ``dummy_fmt`` ``data`` : a property to add ``ndarray`` values, to work in a specified basis. Notes ===== The ``metric`` parameter can be: ``metric = False`` symmetric metric (in Riemannian geometry) ``metric = True`` antisymmetric metric (for spinor calculus) ``metric = None`` there is no metric ``metric`` can be an object having ``name`` and ``antisym`` attributes. If there is a metric the metric is used to raise and lower indices. In the case of antisymmetric metric, the following raising and lowering conventions will be adopted: ``psi(a) = g(a, b)*psi(-b); chi(-a) = chi(b)*g(-b, -a)`` ``g(-a, b) = delta(-a, b); g(b, -a) = -delta(a, -b)`` where ``delta(-a, b) = delta(b, -a)`` is the ``Kronecker delta`` (see ``TensorIndex`` for the conventions on indices). 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_fmt='L') >>> Lorentz.metric metric(Lorentz,Lorentz) c C s`t|trt|}ntj|||r9tjntj}t||_ |smd|j |_ n d||_ |dkrd|_ d|_n||ttddfkrd}||_ n|j }|j|_ ttd|j }t|gd|} | ||_||_|j|_|r;|n||_|j|_g|_|S(Ns%s_%%diiRi(RRRR t__new__RtOnetZerotstrR=REt _dummy_fmtRKRRR;R@tantisymtTensorSymmetryRt TensorTypet_dimtget_kronecker_deltat_deltat_eps_dimt get_epsilont_epsilont_autogenerated( tclsRERRteps_dimRUtobjt metric_nametsym2tS2((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs0'         RRMRi92R s1.1cC s+t|ds$td||_n|jS(Nt _auto_rightt auto_right(RRMR(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC s+t|ds$td||_n|jS(Nt _auto_leftt auto_left(RRMR(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC s+t|ds$td||_n|jS(Nt _auto_indext auto_index(RRMR!(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR"scC stt|S(N(R!t_tensor_data_substitution_dict(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRsc C stddlm}tj|}|jdkrGtdn|jdkr|jdk r|j d}||jkrtdqn|j d}|j ||}x*t |D]\}}||||f>> from sympy.tensor.tensor import TensorIndexType, TensorIndex, TensorSymmetry, TensorType, get_symmetric_group_sgs >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> i = TensorIndex('i', Lorentz); i i >>> sym1 = TensorSymmetry(*get_symmetric_group_sgs(1)) >>> S1 = TensorType([Lorentz], sym1) >>> A, B = S1('A,B') >>> A(i)*B(-i) A(L_0)*B(-L_0) If you want the index name to be automatically assigned, just put ``True`` in the ``name`` field, it will be generated using the reserved character ``_`` in front of its name, in order to avoid conflicts with possible existing indices: >>> i0 = TensorIndex(True, Lorentz) >>> i0 _i0 >>> i1 = TensorIndex(True, Lorentz) >>> i1 _i1 >>> A(i0)*B(-i1) A(_i0)*B(-_i1) >>> A(i0)*B(-i0) A(L_0)*B(-L_0) cC st|trt|}ngt|tr6|}nO|tkrydjt|j}t|}|jj|n tdt |}t j ||||}t ||_ ||_||_|S(Ns_i{0}s invalid name(RRRR;RfR+RRAR?R R RR R=t_tensor_index_typeR>(RREt tensortypeRt name_symbolR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs       cC s|jS(N(R=(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyREsRR2Ri92R s1.1cC s|jS(N(R2(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR;scC s|jS(N(R:(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR2scC s|jS(N(R>(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC s#|j}|jsd|}n|S(Ns-%s(R=R>(R.ts((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_prints   cC s"|j|jf|j|jfkS(N(R2R=(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR5scC s t|j|j|j }|S(N(RMRER2R(R.tt1((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__neg__s (RRRR;RRRERR;R2RR>R5R@(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRMvs9 '  cC st|tr:gt|dtD]}|j^q"}n tdg|D]}t||^qM}t|dkr|dS|S(s 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_fmt='L') >>> a, b, c, d = tensor_indices('a,b,c,d', Lorentz) tseqsexpecting a stringii(RRRR;RER?RMR+(R=RFR$RR4ttilist((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyttensor_indicess+ "RcB sDeZdZdZedZedZedZRS(s Monoterm symmetry of a tensor 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, are not covered. See Also ======== sympy.combinatorics.tensor_can.get_symmetric_group_sgs Examples ======== Define a symmetric tensor >>> from sympy.tensor.tensor import TensorIndexType, TensorSymmetry, TensorType, get_symmetric_group_sgs >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> sym2 = TensorSymmetry(get_symmetric_group_sgs(2)) >>> S2 = TensorType([Lorentz]*2, sym2) >>> V = S2('V') cO st|dkr%|d\}}n-t|dkrF|\}}n tdt|tspt|}nt|tst|}ntj||||}|S(Niiis:bsgs required, either two separate parameters or one tuple(R+t TypeErrorRRR R(RRtkw_argsRRR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR's cC s |jdS(Ni(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR6scC s |jdS(Ni(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR:scC s|jddjdS(Niii(Rtsize(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRx>s(RRRRRRRRx(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs & cG sddlm}d}|s;ttt|dSt|dkrnt|dd|rnt|S||d\}}x?|dD]3}||\}}t||||\}}qWtt||S(s1 Return a ``TensorSymmetry`` object. 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. Examples ======== Symmetric tensor using a Young tableau >>> from sympy.tensor.tensor import TensorIndexType, TensorType, tensorsymmetry >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> sym2 = tensorsymmetry([1, 1]) >>> S2 = TensorType([Lorentz]*2, sym2) >>> V = S2('V') Symmetric tensor using a ``BSGS`` (base, strong generator set) >>> from sympy.tensor.tensor import get_symmetric_group_sgs >>> sym2 = tensorsymmetry(*get_symmetric_group_sgs(2)) >>> S2 = TensorType([Lorentz]*2, sym2) >>> V = S2('V') i(t PermutationcS st|dkr.|d}t|d}nRtd|Dr_t|}t|}n!|ddgkrzt}nt|S(Niics s|]}|dkVqdS(iN((RR$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pys }si(R+RRR tNotImplementedError(RRBtbsgs((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt tableau2bsgsws   iii(tsympy.combinatoricsRGRRR+RR(RRGRJRtsgsRtbasextsgsx((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyttensorsymmetryCs2 ) RcB s_eZdZeZdZedZedZedZ dZ ddZ RS(si Class of tensor types. 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 Examples ======== Define a symmetric tensor >>> from sympy.tensor.tensor import TensorIndexType, tensorsymmetry, TensorType >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> sym2 = tensorsymmetry([1, 1]) >>> S2 = TensorType([Lorentz]*2, sym2) >>> V = S2('V') cK s=|jt|ksttj|t|||}|S(N(RxR+R_R RR(RR)RRER((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC s |jdS(Ni(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR)scC s |jdS(Ni(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC stt|jddS(NR#cS s|jS(N(RE(R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%R&(RdtsetR)(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyttypesscC s$dg|jD]}t|^q S(NsTensorType(%s)(R)R (R.R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRgsicC st|tr:gt|dtD]}|j^q"}n tdt|dkrlt|d||Sg|D]}t|||^qsSdS(s| Return a TensorHead object or a list of TensorHead objects. ``s`` name or string of names ``comm``: commutation group number see ``_TensorManager.set_comm`` Examples ======== Define symmetric tensors ``V``, ``W`` and ``G``, respectively commuting, anticommuting and with no commutation symmetry >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorsymmetry, TensorType, canon_bp >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> a, b = tensor_indices('a,b', Lorentz) >>> sym2 = tensorsymmetry([1]*2) >>> S2 = TensorType([Lorentz]*2, sym2) >>> V = S2('V') >>> W = S2('W', 1) >>> G = S2('G', 2) >>> canon_bp(V(a, b)*V(-b, -a)) V(L_0, L_1)*V(-L_0, -L_1) >>> canon_bp(W(a, b)*W(-b, -a)) 0 RAsexpecting a stringiiN(RRRR;RER?R+R(R.R=RR$tnamesRE((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs + ( RRRR@tis_commutativeRRR)RRQRgR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs  icC se|dkr7gtt|D]}dg^q}nt|}t||}|||}|S(s Function generating tensorhead(s). Parameters ========== name : name or sequence of names (as in ``symbol``) typ : index types sym : same as ``*args`` in ``tensorsymmetry`` comm : commutation group number see ``_TensorManager.set_comm`` Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> a, b = tensor_indices('a,b', Lorentz) >>> A = tensorhead('A', [Lorentz]*2, [[1]*2]) >>> A(a, -b) A(a, -b) If no symmetry parameter is provided, assume there are not index symmetries: >>> B = tensorhead('B', [Lorentz, Lorentz]) >>> B(a, -b) B(a, -b) iN(RKRR+ROR(RERFR2RR4Rtth((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs # + RcB seZdZeZddZedZedZedZ edZ edZ edZ ed Z d Zd Zd Zd ZdZedZejdZejdZdZdZRS(sk Tensor head of the tensor Parameters ========== name : name of the tensor typ : list of TensorIndexType comm : commutation group number Attributes ========== ``name`` ``index_types`` ``rank`` ``types`` : equal to ``typ.types`` ``symmetry`` : equal to ``typ.symmetry`` ``comm`` : commutation group Notes ===== 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 ======== >>> from sympy.tensor.tensor import TensorIndexType, tensorhead, TensorType >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> A = tensorhead('A', [Lorentz, Lorentz], [[1],[1]]) 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, tensorhead >>> from sympy import diag >>> 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, we have to assign an antisymmetric matrix to it, because `[[2]]` stands for the Young tableau representation of an antisymmetric set of two elements: >>> F = tensorhead('F', [Lorentz, Lorentz], [[2]]) 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], [[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 icK st|trt|}n$t|tr6|}n tdtj|}tj||||}|jdj |_ t |j |_ |j|_||_|S(Ns invalid namei(RRRR?RRR RRRER=R+R)t_rankRRR(RRERFRRER<tcomm2iR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs    cC s|jS(N(R=(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyREscC s|jS(N(RU(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRxscC s|jS(N(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC s |jdS(Ni(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRFscC s|jS(N(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC s|jdjS(Ni(RRQ(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRQscC s|jdjS(Ni(RR)(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR)scC s"|j|jf|j|jfkS(N(RER)(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR5scC stj|j|j}|S(s Returns ``0`` if ``self`` and ``other`` commute, ``1`` if they anticommute. Returns ``None`` if ``self`` and ``other`` neither commute nor anticommute. (RRR(R.R4tr((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt commutes_withscC s6d|jdjg|jD]}t|^qfS(Ns%s(%s)t,(REtjoinR)R (R.R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR>scO st|||}|jS(s Returns a tensor with indices. There is a special behavior in case of indices denoted by ``True``, they are considered auto-matrix indices, their slots are automatically filled, and confer to the tensor the behavior of a matrix or vector upon multiplication with another tensor containing auto-matrix indices of the same ``TensorIndexType``. This means indices get summed over the same way as in matrix multiplication. For matrix behavior, define two auto-matrix indices, for vector behavior define just one. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> a, b = tensor_indices('a,b', Lorentz) >>> A = tensorhead('A', [Lorentz]*2, [[1]*2]) >>> t = A(a, -b) >>> t A(a, -b) (Rtdoit(R.R*RER((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRsc C stj6tjddt|jdkr>tdnWdQXtddlm }m }g|j dj dD]}|j^qv}|j}|j }xF|D]>}||||}||d|f|d|df}qW|t dd|S(NtignoretcategorysNo power on abstract tensors.i(RRii(twarningstcatch_warningstfilterwarningsRRRKR?R!RRRRRxR( R.R4RRRTtmetricstmarrayt marraydimR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__pow__s *   *cC stt|S(N(R!R#(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC st|t|RRdRR8R9ReR7(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs(j      cC s"x|D]}|j|}qW|S(N(R(texprRItp((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_get_argtree_poss RcB s.eZdZdZeZdZdZdZdZ dZ dZ dZ d Z d Zd Zd Zd ZeZeZdZdZedZdZdZdZdZdZedZedZedZ edZ!dZ"dZ#RS(sg 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``. ``TensAdd`` objects are put in canonical form using the Butler-Portugal algorithm for canonicalization under monoterm symmetries. ``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(@cC s |tjS(N(Rt NegativeOne(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR@7scC s tdS(N(RH(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__abs__:scC st||jS(N(RR[(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__add__=scC st||jS(N(RR[(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__radd__@scC st|| jS(N(RR[(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__sub__CscC st|| jS(N(RR[(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__rsub__FscC st||jS(s Multiply two tensors using Einstein summation convention. 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, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensorhead('p,q', [Lorentz], [[1]]) >>> t1 = p(m0) >>> t2 = q(-m0) >>> t1*t2 p(L_0)*q(-L_0) (RR[(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__mul__IscC st||jS(N(RR[(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__rmul___scC sDt|}t|tr*tdnt|tj|jS(Nscannot divide by a tensor(RRRR?RRR R[(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__div__bs cC stddS(Nscannot divide by a tensor(R?(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__rdiv__hscC stj6tjddt|jdkr>tdnWdQXtddlm }m }|j }|j}|j }xJ|D]B}||||dj j|d|f|d|df}qW|tdd|S(NR\R]sNo power without ndarray data.i(RRii(R^R_R`RRRKR?R!RRRR'RxR2R(R.R4RRR'RbRR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRdks"      $cC s tdS(N(RH(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt__rpow__scG sI|jt|}|jdd}|jdd}|S(sZ 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, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) >>> A, B = tensorhead('A,B', [Lorentz]*2, [[1]*2]) >>> t = A(i, k)*B(-k, -j); t A(i, L_0)*B(-L_0, -j) >>> t.fun_eval((i, k),(-j, l)) A(k, L_0)*B(-L_0, l) cS s t|tS(N(RR(R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%R&cS s|jd|jdS(Nii(R(R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%R&cS st|ttfS(N(RRR(R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%R&cS st|jjS(N(RRR[(R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%R&(txreplaceRtreplace(R.t index_tuplesRf((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytfun_evalscC s)ddlm}td|jko1dknr|jjd}|jdkre|jjdnd}|jdkrg|}xt|D]E}|jgx/t|D]!}||j|||fqWqWn2dg|}x"t|D]}||||>> 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], [[1]]) >>> A(i).replace_with_arrays({A(i): [1, 2]}, [i]) [1, 2] >>> expr = A(i)*A(j) >>> expr.replace_with_arrays({A(i): [1, 2]}, [i, j]) [[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], [[1], [1]]) >>> 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]]}, [i, j]) [[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, [i, j]) [[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]] i(tArrayc s%i|]\}}||qS(((RRR(R(s2lib/python2.7/site-packages/sympy/tensor/tensor.pys }s isEshapes for tensor %s expected to be %s, replacement array shape is %sN(RRtitemsRRRRR)R+RxRRRRKR;R?t _extract_dataR( R.RR*RRR4texpected_shapet index_typeR*R+t ret_indicest last_indices((Rs2lib/python2.7/site-packages/sympy/tensor/tensor.pytreplace_with_arraysAs:%>c C s{ddlm}|j}|j}g|D]-\}}||d||jjdf^q,}|rw|||}n|S(Ni(tSumii(RyRRJR(R2R( R.Rft index_symbolsRR*R(R4Rzt sum_indices((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_check_add_Sums  7($RRRt _op_priorityR@RSR@RjRkRlRmRnRoRpRqRrRdRst __truediv__t __rtruediv__RwR}RRRRRRRRRRRRRR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs>                    @ WRcB seZdZdZdZedZedZedZdZ e dZ e dZ d Z d Zd Zd Zd ZdZdZdZdZdZdZe dZejdZejdZdZdZRS(sm 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 Notes ===== Sum of more than one tensor are put automatically in canonical form. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensorhead, tensor_indices >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> a, b = tensor_indices('a,b', Lorentz) >>> p, q = tensorhead('p,q', [Lorentz], [[1]]) >>> t = p(a) + q(a); t p(a) + q(a) >>> t(b) p(b) + q(b) 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] cO sMg|D]}|rt|^q}tj|}tj|||}|S(N(RRt_tensAdd_flattenR R(RRRER$R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs%cK sS|jdt}|r@g|jD]}|j|^q"}n |j}|sVtjSt|dkrt|dt r|dSt j |t|dkr|dSg|D]}|r|^q}|stjSt|dkr|dSt j |}d}|j d||s&tjSt|dkr@|dS|j |}|S(NtdeepiicS s>t|}t|ts(gggfS|j|j|jfS(N(tget_index_structureRRR8R'R((RR$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytsort_keys  R#(RR;RR[RR R+RRRt_tensAdd_checkt_tensAdd_collect_termsR-tfunc(R.RRRRR$RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR[s2( &  cC sxg}xI|D]A}t|ttfrA|jt|jq |j|q Wg|D]}|jrY|^qY}|S(N(RR RR6RRRAR(RRR$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s "c stgt|djD]}|d^qg|dD]2}tgt|jD]}|d^qT^q;}tfd|DstdndS(Niic3 s|]}|kVqdS(N((RR$(tindices0(s2lib/python2.7/site-packages/sympy/tensor/tensor.pys ss&all tensors must have the same indices(RPRR'RR?(RR$Rt list_indices((Rs2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s0CcC smtt}tj}t|dtrAt|dj}n tg}x|D]}t|ts|tgkrtdn||7}qTn|t|jkrtdn||j j |j qTWg|j D]9\}}t |dkrtt ||j^q}t|t rMt|j|}n|dkri|g|}n|S(Nis wrong valence(RRRR RRRPReR?tnocoeffRARRR RR[R(Rt terms_dicttscalarst free_indicesRRRtnew_args((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR# s(     L cC sPg}xC|jD]8}|jgt|D]}||kr)|^q)qW|S(N(RR6RJ(R.R*RR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRJ@ s6cC s|jdjS(Ni(RRx(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRxF scC s|jdjS(Ni(RR(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRJ scK s)tg|jD]}t||^q S(N(RRR(R.RR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRN scG s|j}t|}g|D]}|j^qg|D]}|j^q5kr\tdn||krl|Stt||}g|jD]!}|j|j|j^q}t|j }|S(sReturns tensor with ordered free indices replaced by ``indices`` Parameters ========== indices Examples ======== >>> from sympy import Symbol >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> D = Symbol('D') >>> Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L') >>> i0,i1,i2,i3,i4 = tensor_indices('i0:5', Lorentz) >>> p, q = tensorhead('p,q', [Lorentz], [[1]]) >>> g = Lorentz.metric >>> t = p(i0)*p(i1) + g(i0,i1)*q(i2)*q(-i2) >>> t(i0,i2) metric(i0, i2)*q(L_0)*q(-L_0) + p(i0)*p(i2) >>> from sympy.tensor.tensor import canon_bp >>> canon_bp(t(i0,i1) - t(i1,i0)) 0 sincompatible types( RRR2R?RRRRwRR[(R.R*RR$RvRtres((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRQ s  8 1cC sD|j}g|jD]}t|^q}t|j}|S(sz canonicalize using the Butler-Portugal algorithm for canonicalization under monoterm symmetries. (RRR/RR[(R.RfR$RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR/u s "cC st|}t|trA|jdkrAtd|jDSt|tri|j|jkritSnt|t rt |jt |jkrtSt Sn||}t|ts|dkSt|tr|jdkStd|jDSdS(Nics s|]}|jdkVqdS(iN(t_coeff(RR$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pys scs s|]}|jdkVqdS(iN(R(RR$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pys s( RRRRRRRRxR@RRPR;(R.R4R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytequals s     cC st|j|S(N(R!R(R.titem((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC sAg|jD]}|j|^q }t|j}t|S(N(Rtcontract_deltaRR[R/(R.R,R$RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s%cC sAg|jD]}t||^q }t|j}t|S(s0 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 (Rtcontract_metricRR[R/(R.RsR$RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s%cG sL|j}g}x*|D]"}|j|}|j|qWt|jS(ss Return a tensor with free indices substituted according to ``index_tuples`` Parameters ========== index_types : list of tuples ``(old_index, new_index)`` Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) >>> A, B = tensorhead('A,B', [Lorentz]*2, [[1]*2]) >>> t = A(i, k)*B(-k, -j) + A(i, -j) >>> t.fun_eval((i, k),(-j, l)) A(k, L_0)*B(-L_0, l) + A(k, l) (RRwRARR[(R.RvRtargs1R$R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRw s   cG sL|j}g}x*|D]"}|j|}|j|qWt|jS(s Return a tensor with free indices substituted according to ``index_tuples`` Parameters ========== index_types : list of tuples ``(old_index, new_index)`` Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) >>> A, B = tensorhead('A,B', [Lorentz]*2, [[1]*2]) >>> t = A(i, k)*B(-k, -j); t A(i, L_0)*B(-L_0, -j) >>> t.substitute_indices((i,j), (j, k)) A(j, L_0)*B(-L_0, -k) (Rtsubstitute_indicesRARR[(R.RvRRR$R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s   cC sbg}|j}x!|D]}|jt|qW|jdj|}|jdd}|S(Ns + s+ -s- (RRAR R-RZRu(R.RRR$R=((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR> s   c C sddlm}m}tg|jD]0}t|trG|j|n g|f^q#\}}g|D]}||^qi}|d}xVtdt |D]?}||} ||} t j | |} || | ||RRR8R9ReR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs2/  3    $        RcB s'eZdZeZdZedZdZedZ edZ dZ dZ dZ d Zed Zed Zed Zed ZedZedZedZedZedZdZedZdZedZedZedZedZedZ dZ!dZ"dZ#dZ$dZ%d Z&d!Z'd"Z(d#Z)d$Z*d%Z+ed&Z,e,j-d'Z,e,j.d(Z,d)Z/d*Z0d+Z1d,Z2d-Z3RS(.s Base tensor class, i.e. this represents a tensor, the single unit to be put into an expression. This object is usually created from a ``TensorHead``, by attaching indices to it. Indices preceded by a minus sign are considered contravariant, otherwise covariant. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType("Lorentz", dummy_fmt="L") >>> mu, nu = tensor_indices('mu nu', Lorentz) >>> A = tensorhead("A", [Lorentz, Lorentz], [[1], [1]]) >>> A(mu, -nu) A(mu, -nu) >>> A(mu, -mu) A(L_0, -L_0) cK s|jdt}|j||}tj||t||}tj||_t |jj |_ |j t |krtdn||_||_tj||j|_|S(NRtswrong number of indices(tpopR@t_parse_indicesR RRR"R5t_index_structureRPRet_free_indices_setRxR+R?t_indicest _is_canon_bpRt_build_index_mapt _index_map(Rt tensor_headR*RERtR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR5 s  cC s1i}x$|D]}|j|f||m si(RPt itertoolstchainRR(R<R(R.((Rs2lib/python2.7/site-packages/sympy/tensor/tensor.pyRk scC st|jdjS(Ni(RPR(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRo scC s|jS(N(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRtr scC s|jS(N(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR*v scC s |jjS(N(RR'(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR'z scC s)g|jD]\}}||df^q S(Ni(R'(R.R`RI((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt free_in_args~ scC s |jjS(N(RR((R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR( scC s,g|jD]\}}||ddf^q S(Ni(R((R.tp1tp2((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt dum_in_args scC s t|jS(N(R+R'(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRx scC s |jjS(N(RR,(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC s$tg|jD]}|d^q S(Ni(RdR'(R.R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC s9t|tsdSt|tr5|jj|jStS(s :param other: :return: 0 commute 1 anticommute None neither commute nor anticommute i(RRRR9RXRH(R.R4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRX s cC st|||S(s Returns the tensor corresponding to the permutation ``g`` For further details, see the method in ``TIDS`` with the same name. (R}(R.RsRt((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR} scC s|jr |S|j}|jj\}}}t|jg}t||||}|dkrktjS|j |t }|S(Ni( RRRRlRR9RRR R}R;(R.RfRsRRRtcanR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR/ s   cC st|jjS(N(RR9R)(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR) scC stjS(N(RR (R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC s|S(N((R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC s |jdS(Ni(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR9 scC s|jdgS(Ni(R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR8 scC s|gS(N((R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR[ scK s|S(N((R.R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC s|S(N((R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytsorted_components scC st|jdS(sN Get a list of indices, corresponding to those of the tensor. i(RR(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRJ scC s |jjS(sS Get a list of free indices, corresponding to those of the tensor. (RRe(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRe scC s |tjfS(N(RR (R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt as_base_exp scG s t||S(N(R(R.Rv((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scG s|j}t|}g|D]}|j^qg|D]}|j^q5kr\tdn||krl|S|jtt||}ttd|Dt|kr|j|j S|S(s Returns tensor with ordered free indices replaced by ``indices`` Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> i0,i1,i2,i3,i4 = tensor_indices('i0:5', Lorentz) >>> A = tensorhead('A', [Lorentz]*5, [[1]*5]) >>> t = A(i2, i1, -i2, -i3, i4) >>> t A(L_0, i1, -L_0, -i3, i4) >>> t(i1, i2, i3) A(L_0, i1, -L_0, i2, i3) sincompatible typescs s%|]}|jr|n| VqdS(N(R(RR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pys  s( RRR2R?RwRR+RPRR(R.R*RR$R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s  8 (cC st|jjS(N(R!RRe(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRe scC st|j|S(N(R!R(R.R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR sc sddlmxi|jD]E\}}t|tr|jd|jdkr|}|}PqqWtd||ffd|jD}|}|j}|j}t|dkr x-|D]%}||krt d|qqWg|D]}||kr|^q}nt|dkr|j } i} x'|D]\} } | |  | | |  s s'%s with contractions is not implemented(RRRRRRR?R(R+RHRJRtR[RRReR(R.RRRR4Rtdum1tdum2tpairRtreplRRRR((Rs2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s4)     ( !  cC stt|S(N(R!R#(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR5 scC st|t|H s " cC sp|dkr|jdkSt|}t|tsQ|j sDttj|kSd}||||kS(NicS sL|j}|jt|jtt|jtt|jf}|S(N(R/RRrR8RdR'R((R.RRW((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_get_compar_compX s *(RRRRR8R_RR (R.R4R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRP s     cC s|j|kr|St|jdkr,|S|jdj}tj}|jd}|s|jdkrvt dn||j}nT|jdkrt dn||j}|j d\}}||kr| }n|S(Nisdimension not assigned( R9R+R'R)RRR RRKR?R((R.RsR tsignRFtdp0tdp1((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR` s$     cC s |j|S(N(R(R.R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR~ scC s\ddlm}g|jD]}|jd^q}||jd|}|j||S(Ni(tIndexedi(RyRRJRR(R.RR*RR4RRf((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s&(4RRRR@RSRRRR[RRRRRRRRtR*R'RR(RRxRRRXR}R/R)RRR9R8R[RRRJReRRRReRRRR8R9R>RRRR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s^                    %    RcB sceZdZejZdZedZedZ ee dZ edZ edZ dZedZed Zd Zd Zd Zed ZedZedZedZedZedZedZedZedZedZedZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'd Z(d!Z)e*d"Z+d#Z,d$Z-d%Z.d&Z/e*d'Z0d(Z1ed)Z2d*Z3d+Z4d,Z5ed-Z6e6j7d.Z6e6j8d/Z6d0Z9d1Z:RS(2s 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. c O s5|jdt}ttt|}g|D]:}t|ttfrR|jn|gD] }|^qYq.}tj |dt\}}}}g|D]}|j ^q} t ||| |d|} t j ||} || _| | _| | _t| jjdt| jj| _tj| _|| _| S(NRttreplace_indicesR/i(RR@RRRRRRRRR2R"RRRt _index_typesRR+R'R(R,RR RR( RRRERtRR4R*R'R(R)RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR sG!   )  cC si}i}g}g}d}x!t|D]\}}xt|D]\}} t| tsntdn| |kr|j| } |j| } | jr|j| || || fn|j| | || |f|j| n@| |krtd| n!||| <||| <|j| |d7}qDWq+Wg|jD]\} } | | f^qO}g|j D]} | j ^qz}|j dd||||fS(Nisexpected TensorIndexsRepeated index: %siR#cS s|dS(Ni((R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR% R&( R<RRMRDRRRAR?RtkeysRER-(Rt free2pos1t free2pos2t dummy_dataR*RQRPt arg_indicest index_posRDt other_pos1t other_pos2R4RgR't free_names((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_indices_to_free_dum s4       +"cC s,g|D]!\}}}}}||f^qS(N((RR4tp1atp1btp2atp2b((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt_dummy_data_to_dum sc s^g|D] }i^q}g|D]}t|^q }tj|\}}}} ttfd} |r?x| D]\} } } }}| j}x&tr| |}||krPqqWt||t}||| | <| || | <|||<| |||dSt j|\}}}} g|D]} | j^q`} t|| | |d|} |j|} | | _| | _t | jjdt | jj| _|| _|| _| S(NRcS s||S(N((Rtb((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%C R&iiR/i(RRR;RR[tidentityRRRRR R+R RRR2R"RRRR'R(R,R(R.RRtRRRRR*R'R(R4R)RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR[8 s4 ( (:(   )  cK s%t|tj||||jS(N(Rt%_get_tensors_from_components_free_dumR[(RR8R'R(RE((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt from_dataa sc C stj|||}|j}g|D] }d^q(}d}xGt|D]9\}}|} ||j7}t||| |!||{ s(RPRRR(R<RRJ(R.((Rs2lib/python2.7/site-packages/sympy/tensor/tensor.pyRy scC sgt|jD] }d^q}d}xgt|jD]V\}}t|tsYq8nx%t|jD]}||||>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensorhead('p,q', [Lorentz], [[1]]) >>> 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] (R(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRJ scC s |jjS(s Returns the list of free indices of the tensor The indices are listed in the order in which they appear in the component tensors. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensorhead('p,q', [Lorentz], [[1]]) >>> t = p(m1)*g(m0,m2) >>> t.get_free_indices() [m1, m0, m2] >>> t2 = p(m1)*g(-m1, m2) >>> t2.get_free_indices() [m2] (RRe(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRe scC sm|jdkr|gSg}d}xD|jD]9}t|tr[|j||d}q,||9}q,W|S(s Returns a list of tensors, whose product is ``self`` 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, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> a, b, c, d = tensor_indices('a,b,c,d', Lorentz) >>> A, B = tensorhead('A,B', [Lorentz]*2, [[1]*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)] i((RRRRA(R.tsplitpRR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR[ s cK sg|jD]}t||^q }g|D]-}t|ttfrP|jn|f^q,}tgtj|D]}t|^qrS(N(RRRR RRtproductR(R.RRRRR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s%:cC sttj|d|jjS(NRt(RRRiRR[(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR@ scC st|j|S(N(R!R(R.R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR! scC skt|j}|jdktkr[d}|jtjkrI|d}qa|d |d>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> A = tensorhead('A', [Lorentz]*2, [[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 i(RRRRR/R8RRRlRRRR R}R;( R.RfRRsRRRRttmul((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR/] s      cC s|j|}|S(N(R(R.R,R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR scC st}d}xut|jD]d\}}t|ts@qnt|tsUtx+t|jD]}|||<|d7}qeWqW|S(sU Get a dict mapping the index position to TensMul's argument number. ii( RR<RRRRR_RR(R.tpos_mapt pos_countertarg_iRR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s  cC s|j}||kr1|j}|j|S|j}t|j}|jdj}gt|jD]0\}}t |t rl|j |krl|^ql}|s|Sd} |j } |j } t} x|D]} | | krqng| D] }||d| kr|^q}g| D]4}||d| ksP||d| kr"|^q"}|shqn| j| d|| >> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) >>> g = Lorentz.metric >>> p, q = tensorhead('p,q', [Lorentz], [[1]]) >>> 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) iiisdimension not assignedN(RR/RRRRR)RR<RRR9R(R'RPtaddR+RARRKR?RRR[RR"R:R8R(R.RsRfRRR R4R$tgposRR(R'telimtgposxtfree1Rtdum10tdum11tp0RRRRFR`RgtshifttshiftsRR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR s     F     -A                       %)  AicC s|j}|jd||S(NRt(RJR(R.RRtR*((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR3s c O st||jkr$tdnt|j}d}|jdt}xut|D]g\}}t|t szqYnt|t st |j}|j ||||!||<||7}qYWt d||jS(Nsindices length mismatchiRt(R+RR?RRRR@R<RRRR_RRR[( R.R*RERRIRtR4RR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR7s cC s?x8|D]0}t|ts"qnt|tstqWdS(N(RRRR_(RR'R(R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt&_index_replacement_for_contract_metricFs cG s t||S(N(R(R.Rv((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRMscG s|j}t|}g|D]}|j^qg|D]}|j^q5kr\tdn||krl|S|jtt||}ttd|Dt|kr|j|j S|S(s:Returns tensor product with ordered free indices replaced by ``indices`` Examples ======== >>> from sympy import Symbol >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> D = Symbol('D') >>> Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L') >>> i0,i1,i2,i3,i4 = tensor_indices('i0:5', Lorentz) >>> g = Lorentz.metric >>> p, q = tensorhead('p,q', [Lorentz], [[1]]) >>> t = p(i0)*q(i1)*q(-i1) >>> t(i1) p(i1)*q(L_0)*q(-L_0) sincompatible typescs s%|]}|jr|n| VqdS(N(R(RR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pys ks( RRR2R?RwRR+RPRR(R.R*RR$R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRPs  8 (cC stg|jD]$}t|tr |j|^q \}}ttjg|jD]}t|tsS|^qStj }t j |\}}} } t j | } |j } |jddg|D]} | d^q}||tj|| | fS(NR#cS s|dS(Ni((R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%uR&i(RRRRRRtoperatortmulRR RRRRR-RR(R.RRRRRRR*R'RRR(RR4R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRos@= cC stt|j}|S(N(R!R#R(R.R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRyscC sttddS(Ns9Not possible to set component data to a tensor expression(R!R?(R.R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC sttddS(Ns<Not possible to delete component data to a tensor expression(R!R?(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC s2t|jdkr%tdn|jjS(Ns No iteration on abstract tensors(R!RRKR?Re(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRescG sddlm}g|jD]}|jd^q}g|D](}t||r_|jdn|^q=}tj|}|j||S(Ni(Ri(RyRRJRRRRR(R.RRR4RRRf((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs &5(;RRRRR R RRRRR;RRR R[RRRRRRRR8R'RRRR(RRxRR)RRJReR[RR@RRRRR@R}R/RRRRRR*RRRRR8R9ReR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR sh&  /! )      !      #        t TensorElementcB sneZdZdZedZedZedZedZdZ dZ dZ RS( s Tensor with evaluated components. Examples ======== >>> from sympy.tensor.tensor import TensorIndexType, tensorhead >>> from sympy import symbols >>> L = TensorIndexType("L") >>> i, j, k = symbols("i j k") >>> A = tensorhead("A", [L, L], [[1], [1]]) >>> 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 s t|ts]t|ts1td|n|jg|jD]}t||^qAS|jdDfd|jD}fd|jD}t |dkr|SgD]}||j kr|^q}t |}tj |||}||_ |S(Ns%s is not a tensor expressioncS s i|]}||jdqS(i(R(RR4((s2lib/python2.7/site-packages/sympy/tensor/tensor.pys s c s+i|]!\}}|j||qS((R(RRDR(tname_translation(s2lib/python2.7/site-packages/sympy/tensor/tensor.pys s c s+i|]!\}}|kr||qS(((RRDR(texpr_free_indices(s2lib/python2.7/site-packages/sympy/tensor/tensor.pys s i(RRRRDRRR-ReRR+RRRt _free_indices(RRfRRR4RR((R/R.s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs, +  cC s/gt|jD]\}}||f^qS(N(R<Re(R.R4RD((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR'scC sgS(N((R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR(scC s |jdS(Ni(t_args(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRfscC s |jdS(Ni(R1(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRscC s|jS(N(R0(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRescC s |jS(N(Re(R.((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRJsc s{|jj|\}}|jtfd|D}g|D]}|krD|^qD}|j|}||fS(Nc3 s'|]}j|tdVqdS(N(RtsliceRK(RR4(R(s2lib/python2.7/site-packages/sympy/tensor/tensor.pys s(RfRRRrR(R.RRRt slice_tupleR4((Rs2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs  %( RRRRRR'R(RfRReRJR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR-s   cC st|tr|jS|S(s* Butler-Portugal canonicalization (RRR/(Rg((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR/s cG sL|stjtjgggS|d}x|dD]}||}q4W|S(s product of tensors ii(RRRR (RRttx((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyt tensor_muls  c C st|jdd}g|D]}|d^q\}}}}tdd|}td d|j||f||f||f||f}tdd|j||f||f||f||f} ||| } | S(s 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)`` R#cS s|dS(Ni((R$((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyR%R&iiii(RdR'RR( tt_rR'R$RRBRgtqtt0R?tt2tt3((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytriemann_cyclic_replaces)?>c C s|j}t|ttfr-|g}n |j}g|D]}|j^q=}g|D]%}g|D]}t|^qi^q\}g|D]}t|^q}t|j } | s| St | SdS(s) 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 >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) >>> R = tensorhead('R', [Lorentz]*4, [[2, 2]]) >>> t = R(i,j,k,l)*(R(-i,-j,-k,-l) - 2*R(-i,-k,-j,-l)) >>> riemann_cyclic(t) 0 N( RRRRRR[R;R5RR[R/( R9RR$ta1RR4ta2Rta3R:((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytriemann_cyclics   2cC sod}|j}i}x|jD]}t|ts=q"n||krOq"n|j}g}x:tt|D]&}|||krq|j|qqqqWt|dkrtd|nt|dkr"|||>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensorhead >>> Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) >>> A, B = tensorhead('A,B', [Lorentz]*2, [[1]*2]) >>> t = A(i, k)*B(-k, -j); t A(i, L_0)*B(-L_0, -j) >>> t.substitute_indices((i,j), (j, k)) A(j, L_0)*B(-L_0, -k) ( RRR'R=R2R>RARRRR8R((RRvR'R$RzR^R4R((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs $!cK s-t|tr|j|S|j|SdS(N(RRRR(RfR((s2lib/python2.7/site-packages/sympy/tensor/tensor.pyRs (TRt __future__RRt collectionsRR+RRyRRRtsympy.combinatorics.tensor_canRRRR t sympy.coreR R R R RRtsympy.core.compatibilityRRRRtsympy.core.containersRRtsympy.core.decoratorsRtsympy.core.symbolRRtsympy.core.sympifyRRtsympy.core.operationsRtsympy.matricesRtsympy.utilities.exceptionsRR^R!R"RRR#tobjectRRRRMRCRRORRKRRRhRRRRR-R/R5R;R?RVReRJRRWRR@R}RR(((s2lib/python2.7/site-packages/sympy/tensor/tensor.pytst  "." $ i  m C PX+ znN   ! x      '