ó ¡¼™\c@ s•ddlmZmZddlmZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZddlmZddlmZddlmZdd lmZdd lm Z dd l!m"Z"d e fd „ƒYZ#de fd„ƒYZ$de fd„ƒYZ%de fd„ƒYZ&defd„ƒYZ'defd„ƒYZ(de fd„ƒYZ)de fd„ƒYZ*de fd„ƒYZ+de+fd„ƒYZ,d e fd!„ƒYZ-d"e fd#„ƒYZ.d$e fd%„ƒYZ/d&e0e1d'„Z2e0d(„Z3d)„Z4e1d*„Z5e1d+„Z6d,„Z7d-„Z8d.„Z9d/„Z:d0„Z;d1„Z<d2S(3iÿÿÿÿ(tprint_functiontdivision(t permutations(t Permutation( t AtomicExprtBasictExprtDummytFunctiontsympifytdifftPowtMultAddtsymbolstTuple(trangetreduce(tZero(t factorial(tMatrix(tsimplify(tsolve(tImmutableDenseNDimArraytManifoldcB s eZdZd„Zd„ZRS(s Object representing a mathematical manifold. The only role that this object plays is to keep a list of all patches defined on the manifold. It does not provide any means to study the topological characteristics of the manifold that it represents. cC sLt|ƒ}t|ƒ}tj|||ƒ}||_||_g|_|S(N(R Rt__new__tnametdimtpatches(tclsRRtobj((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRs     cG s d|jS(Ns \text{%s}(R(tselftprintertargs((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyt_latex)s(t__name__t __module__t__doc__RR"(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRs tPatchcB s/eZdZd„Zed„ƒZd„ZRS(sšObject representing a patch on a manifold. On a manifold one can have many patches that do not always include the whole manifold. On these patches coordinate charts can be defined that permit the parameterization of any point on the patch in terms of a tuple of real numbers (the coordinates). This object serves as a container/parent for all coordinate system charts that can be defined on the patch it represents. Examples ======== Define a Manifold and a Patch on that Manifold: >>> from sympy.diffgeom import Manifold, Patch >>> m = Manifold('M', 3) >>> p = Patch('P', m) >>> p in m.patches True cC sSt|ƒ}tj|||ƒ}||_||_|jjj|ƒg|_|S(N(R RRRtmanifoldRtappendt coord_systems(RRR'R((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRFs    cC s |jjS(N(R'R(R((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRQscG s d|j|jj||ŒfS(Ns\text{%s}_{%s}(RR'R"(RR R!((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR"Us(R#R$R%RtpropertyRR"(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR&-s t CoordSystemcB s¹eZdZdd„Zed„ƒZeed„Z e d„ƒZ e d„ƒZ d„Z d„Zd„Zd „Zd „Zd „Zd „Zd „Zd„Zd„Zd„ZRS(s_ Contains all coordinate transformation logic. Examples ======== Define a Manifold and a Patch, and then define two coord systems on that patch: >>> from sympy import symbols, sin, cos, pi >>> from sympy.diffgeom import Manifold, Patch, CoordSystem >>> from sympy.simplify import simplify >>> r, theta = symbols('r, theta') >>> m = Manifold('M', 2) >>> patch = Patch('P', m) >>> rect = CoordSystem('rect', patch) >>> polar = CoordSystem('polar', patch) >>> rect in patch.coord_systems True Connect the coordinate systems. An inverse transformation is automatically found by ``solve`` when possible: >>> polar.connect_to(rect, [r, theta], [r*cos(theta), r*sin(theta)]) >>> polar.coord_tuple_transform_to(rect, [0, 2]) Matrix([ [0], [0]]) >>> polar.coord_tuple_transform_to(rect, [2, pi/2]) Matrix([ [0], [2]]) >>> rect.coord_tuple_transform_to(polar, [1, 1]).applyfunc(simplify) Matrix([ [sqrt(2)], [ pi/4]]) Calculate the jacobian of the polar to cartesian transformation: >>> polar.jacobian(rect, [r, theta]) Matrix([ [cos(theta), -r*sin(theta)], [sin(theta), r*cos(theta)]]) Define a point using coordinates in one of the coordinate systems: >>> p = polar.point([1, 3*pi/4]) >>> rect.point_to_coords(p) Matrix([ [-sqrt(2)/2], [ sqrt(2)/2]]) Define a basis scalar field (i.e. a coordinate function), that takes a point and returns its coordinates. It is an instance of ``BaseScalarField``. >>> rect.coord_function(0)(p) -sqrt(2)/2 >>> rect.coord_function(1)(p) sqrt(2)/2 Define a basis vector field (i.e. a unit vector field along the coordinate line). Vectors are also differential operators on scalar fields. It is an instance of ``BaseVectorField``. >>> v_x = rect.base_vector(0) >>> x = rect.coord_function(0) >>> v_x(x) 1 >>> v_x(v_x(x)) 0 Define a basis oneform field: >>> dx = rect.base_oneform(0) >>> dx(v_x) 1 If you provide a list of names the fields will print nicely: - without provided names: >>> x, v_x, dx (rect_0, e_rect_0, drect_0) - with provided names >>> rect = CoordSystem('rect', patch, ['x', 'y']) >>> rect.coord_function(0), rect.base_vector(0), rect.base_oneform(0) (x, e_x, dx) cC s t|ƒ}|sAgt|jƒD]}d||f^q"}nt|tƒrktj||||ƒ}n*tt|ƒŒ}tj||||ƒ}||_g|j D]}t |ƒ^q¨|_ ||_ |j j j|ƒi|_g|D]}tt |ƒƒ^qï|_tƒ|_|S(Ns%s_%d(R RRt isinstanceRRRRRR!tstrt_namestpatchR)R(t transformsRt_dummiest_dummy(RRR/tnamestiRtn((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRµs / %  ( cC s |jjS(N(R/R(R((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRÐscC smt||ƒ\}}t|ƒt|ƒf|j|<|rV|j||ƒ|j|t staticmethodR7R8RLRMRQRRRTRURWRXRZR[R"(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR+Ys"Y       RYcB s2eZdZd„Zdd„Zed„ƒZRS(scPoint in a Manifold object. To define a point you must supply coordinates and a coordinate system. The usage of this object after its definition is independent of the coordinate system that was used in order to define it, however due to limitations in the simplification routines you can arrive at complicated expressions if you use inappropriate coordinate systems. Examples ======== Define the boilerplate Manifold, Patch and coordinate systems: >>> from sympy import symbols, sin, cos, pi >>> from sympy.diffgeom import ( ... Manifold, Patch, CoordSystem, Point) >>> r, theta = symbols('r, theta') >>> m = Manifold('M', 2) >>> p = Patch('P', m) >>> rect = CoordSystem('rect', p) >>> polar = CoordSystem('polar', p) >>> polar.connect_to(rect, [r, theta], [r*cos(theta), r*sin(theta)]) Define a point using coordinates from one of the coordinate systems: >>> p = Point(polar, [r, 3*pi/4]) >>> p.coords() Matrix([ [ r], [3*pi/4]]) >>> p.coords(rect) Matrix([ [-sqrt(2)*r/2], [ sqrt(2)*r/2]]) cC sDtt|ƒjƒ||_t|ƒ|_|j|jf|_dS(N(tsuperRYt__init__t _coord_sysRt_coordst_args(Rt coord_sysRJ((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR`‚s cC s'|r|jj||jƒS|jSdS(sªCoordinates of the point in a given coordinate system. If ``to_sys`` is ``None`` it returns the coordinates in the system in which the point was defined.N(RaRLRb(RR9((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRJˆscC st‚|jjS(N(RHRbt free_symbols(R((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRe’sN(R#R$R%R`R\RJR*Re(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRY\s%  ROcB s8eZdZeZd„Zd„ZeƒZd„Z RS(sšBase Scalar Field over a Manifold for a given Coordinate System. A scalar field takes a point as an argument and returns a scalar. A base scalar field of a coordinate system takes a point and returns one of the coordinates of that point in the coordinate system in question. To define a scalar field you need to choose the coordinate system and the index of the coordinate. The use of the scalar field after its definition is independent of the coordinate system in which it was defined, however due to limitations in the simplification routines you may arrive at more complicated expression if you use unappropriate coordinate systems. You can build complicated scalar fields by just building up SymPy expressions containing ``BaseScalarField`` instances. Examples ======== Define boilerplate Manifold, Patch and coordinate systems: >>> from sympy import symbols, sin, cos, pi, Function >>> from sympy.diffgeom import ( ... Manifold, Patch, CoordSystem, Point, BaseScalarField) >>> r0, theta0 = symbols('r0, theta0') >>> m = Manifold('M', 2) >>> p = Patch('P', m) >>> rect = CoordSystem('rect', p) >>> polar = CoordSystem('polar', p) >>> polar.connect_to(rect, [r0, theta0], [r0*cos(theta0), r0*sin(theta0)]) Point to be used as an argument for the filed: >>> point = polar.point([r0, 0]) Examples of fields: >>> fx = BaseScalarField(rect, 0) >>> fy = BaseScalarField(rect, 1) >>> (fx**2+fy**2).rcall(point) r0**2 >>> g = Function('g') >>> ftheta = BaseScalarField(polar, 1) >>> fg = g(ftheta-pi) >>> fg.rcall(point) g(-pi) cC s1tj||t|ƒƒ}||_||_|S(N(RRR Rat_index(RRdtindexR((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRÏs  cG sY|d}t|ƒdks,t|tƒ r0|S|j|jƒ}t||jƒjƒS(sfEvaluating the field at a point or doing nothing. If the argument is a ``Point`` instance, the field is evaluated at that point. The field is returned itself if the argument is any other object. It is so in order to have working recursive calling mechanics for all fields (check the ``__call__`` method of ``Expr``). ii(tlenR,RYRJRaRRftdoit(RR!RZRJ((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyt__call__Õs  "cC s|S(N((R((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRiès( R#R$R%RCtis_commutativeRRjtsetReRi(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRO˜s 3   RScB s&eZdZeZd„Zd„ZRS(sVector Field over a Manifold. A vector field is an operator taking a scalar field and returning a directional derivative (which is also a scalar field). A base vector field is the same type of operator, however the derivation is specifically done with respect to a chosen coordinate. To define a base vector field you need to choose the coordinate system and the index of the coordinate. The use of the vector field after its definition is independent of the coordinate system in which it was defined, however due to limitations in the simplification routines you may arrive at more complicated expression if you use unappropriate coordinate systems. Examples ======== Use the predefined R2 manifold, setup some boilerplate. >>> from sympy import symbols, pi, Function >>> from sympy.diffgeom.rn import R2, R2_p, R2_r >>> from sympy.diffgeom import BaseVectorField >>> from sympy import pprint >>> x0, y0, r0, theta0 = symbols('x0, y0, r0, theta0') Points to be used as arguments for the field: >>> point_p = R2_p.point([r0, theta0]) >>> point_r = R2_r.point([x0, y0]) Scalar field to operate on: >>> g = Function('g') >>> s_field = g(R2.x, R2.y) >>> s_field.rcall(point_r) g(x0, y0) >>> s_field.rcall(point_p) g(r0*cos(theta0), r0*sin(theta0)) Vector field: >>> v = BaseVectorField(R2_r, 1) >>> pprint(v(s_field)) / d \| |-----(g(x, xi_2))|| \dxi_2 /|xi_2=y >>> pprint(v(s_field).rcall(point_r).doit()) d ---(g(x0, y0)) dy0 >>> pprint(v(s_field).rcall(point_p)) / d \| |-----(g(r0*cos(theta0), xi_2))|| \dxi_2 /|xi_2=r0*sin(theta0) cC s7t|ƒ}tj|||ƒ}||_||_|S(N(R RRRaRf(RRdRgR((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR*s    cC s¡t|ƒst|ƒr'tdƒ‚n|dkr7|St|jtƒƒ}|jj}gt |ƒD]"\}}t d|ƒ|ƒ^qe}|j tt ||ƒƒƒ}|j |ƒ}|jj}g|D]} | j |ƒ^qÍ} g} xC|D];}|jj|j|ƒ} | j| |j|jfƒqõW|j tt | | ƒƒƒ}|j tt ||ƒƒƒ} | j tt ||jjƒƒƒƒ} | jƒS(sÆApply on a scalar field. The action of a vector field on a scalar field is a directional differentiation. If the argument is not a scalar field an error is raised. sAOnly scalar fields can be supplied as arguments to vector fields.s_#_%sN(tcovariant_ordertcontravariant_ordert ValueErrorR\RBtatomsRORaR2t enumerateRRIRAR R1RMR(RfRRRi(Rt scalar_fieldt base_scalarstd_varR4tbtd_funcstd_resultRJtft d_funcs_derivtd_funcs_deriv_subtjactresult((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRj1s(  2 " !'(R#R$R%R]RkRRj(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRSìs: t CommutatorcB s)eZdZd„Zd„Zd„ZRS(s5Commutator of two vector fields. The commutator of two vector fields `v_1` and `v_2` is defined as the vector field `[v_1, v_2]` that evaluated on each scalar field `f` is equal to `v_1(v_2(f)) - v_2(v_1(f))`. Examples ======== Use the predefined R2 manifold, setup some boilerplate. >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import Commutator >>> from sympy import pprint >>> from sympy.simplify import simplify Vector fields: >>> e_x, e_y, e_r = R2.e_x, R2.e_y, R2.e_r >>> c_xy = Commutator(e_x, e_y) >>> c_xr = Commutator(e_x, e_r) >>> c_xy 0 Unfortunately, the current code is not able to compute everything: >>> c_xr Commutator(e_x, e_r) >>> simplify(c_xr(R2.y**2)) -2*y**2*cos(theta)/(x**2 + y**2) cC sßt|ƒs<t|ƒdks<t|ƒs<t|ƒdkrKtdƒ‚n||kr^tƒStƒjg||fD]}|jtƒ^qtŒ}t|ƒdkr¿t d„||fDƒƒrÇtƒSg||fD]}t |jt ƒƒ^qÔ\}}g|D]}|j ƒj |ƒ^q}g|D]}|j ƒj |ƒ^q*} d} xgt||ƒD]V\} } xGt| |ƒD]6\} }| | | | ƒ|| || ƒ| 7} q}WqaW| Stt|ƒj|||ƒSdS(Nis0Only commutators of vector fields are supported.cs s|]}t|tƒVqdS(N(R,RS(t.0tv((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys …si(RmRnRoRRltunionRpR+RhtallRBRStexpandtcoeffRAR_R}R(Rtv1tv2RRdtbases_1tbases_2Rutcoeffs_1tcoeffs_2trestc1tb1tc2tb2((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRzs(  41((2cC s8tt|ƒjƒ||f|_||_||_dS(N(R_R}R`Rct_v1t_v2(RR„R…((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR`“s cC s,|j|j|ƒƒ|j|j|ƒƒS(sdApply on a scalar field. If the argument is not a scalar field an error is raised. (RR(RRr((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRj™s(R#R$R%RR`Rj(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR}Xs!  RVcB s/eZdZeZd„Zd„Zd„ZRS(s3Return the differential (exterior derivative) of a form field. The differential of a form (i.e. the exterior derivative) has a complicated definition in the general case. The differential `df` of the 0-form `f` is defined for any vector field `v` as `df(v) = v(f)`. Examples ======== Use the predefined R2 manifold, setup some boilerplate. >>> from sympy import Function >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import Differential >>> from sympy import pprint Scalar field (0-forms): >>> g = Function('g') >>> s_field = g(R2.x, R2.y) Vector fields: >>> e_x, e_y, = R2.e_x, R2.e_y Differentials: >>> dg = Differential(s_field) >>> dg d(g(x, y)) >>> pprint(dg(e_x)) / d \| |-----(g(xi_1, y))|| \dxi_1 /|xi_1=x >>> pprint(dg(e_y)) / d \| |-----(g(x, xi_2))|| \dxi_2 /|xi_2=y Applying the exterior derivative operator twice always results in: >>> Differential(dg) 0 cC sNt|ƒrtdƒ‚nt|tƒr1tƒStt|ƒj||ƒSdS(Ns;A vector field was supplied as an argument to Differential.(RnRoR,RVRR_R(Rt form_field((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRÔs   cC s/tt|ƒjƒ||_|jf|_dS(N(R_RVR`t _form_fieldRc(RR‘((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR`Ýs c G sZtd„|Dƒƒr%tdƒ‚nt|ƒ}|dkr_|dr[|dj|jƒS|S|j}|}d}xÛt|ƒD]Í}||j|j|| ||dŒƒ}|d||7}x†t|d|ƒD]q}t||||ƒ} | rÙ|j| f|| ||d|!||dŒ}|d|||7}qÙqÙWqW|SdS(suApply on a list of vector_fields. If the number of vector fields supplied is not equal to 1 + the order of the form field inside the differential the result is undefined. For 1-forms (i.e. differentials of scalar fields) the evaluation is done as `df(v)=v(f)`. However if `v` is ``None`` instead of a vector field, the differential is returned unchanged. This is done in order to permit partial contractions for higher forms. In the general case the evaluation is done by applying the form field inside the differential on a list with one less elements than the number of elements in the original list. Lowering the number of vector fields is achieved through replacing each pair of fields by their commutator. If the arguments are not vectors or ``None``s an error is raised. cs s9|]/}t|ƒdks't|ƒo0|dk VqdS(iN(RnRmR\(R~ta((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys õssHThe arguments supplied to Differential should be vector fields or Nones.iiiÿÿÿÿN(tanyRoRhtrcallR’RR}( Rt vector_fieldstkRxRtretR4REtjtc((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRjâs(      ,5!(R#R$R%R]RkRR`Rj(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRV¡s / t TensorProductcB s)eZdZd„Zd„Zd„ZRS(sÆTensor product of forms. The tensor product permits the creation of multilinear functionals (i.e. higher order tensors) out of lower order fields (e.g. 1-forms and vector fields). However, the higher tensors thus created lack the interesting features provided by the other type of product, the wedge product, namely they are not antisymmetric and hence are not form fields. Examples ======== Use the predefined R2 manifold, setup some boilerplate. >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import TensorProduct >>> TensorProduct(R2.dx, R2.dy)(R2.e_x, R2.e_y) 1 >>> TensorProduct(R2.dx, R2.dy)(R2.e_y, R2.e_x) 0 >>> TensorProduct(R2.dx, R2.x*R2.dy)(R2.x*R2.e_x, R2.e_y) x**2 >>> TensorProduct(R2.e_x, R2.e_y)(R2.x**2, R2.y**2) 4*x*y >>> TensorProduct(R2.e_y, R2.dx)(R2.y) dx You can nest tensor products. >>> tp1 = TensorProduct(R2.dx, R2.dy) >>> TensorProduct(tp1, R2.dx)(R2.e_x, R2.e_y, R2.e_x) 1 You can make partial contraction for instance when 'raising an index'. Putting ``None`` in the second argument of ``rcall`` means that the respective position in the tensor product is left as it is. >>> TP = TensorProduct >>> metric = TP(R2.dx, R2.dx) + 3*TP(R2.dy, R2.dy) >>> metric.rcall(R2.e_y, None) 3*dy Or automatically pad the args with ``None`` without specifying them. >>> metric.rcall(R2.e_y) 3*dy cG s³tg|D](}t|ƒt|ƒdkr |^q Œ}g|D]"}t|ƒt|ƒrB|^qB}|r«t|ƒdkrŽ||dS|tt|ƒj||ŒS|SdS(Nii(R RmRnRhR_R›R(RR!tmtscalart multifields((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRDs;/ cG s tt|ƒjƒ||_dS(N(R_R›R`Rc(RR!((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR`Nsc G s,t|ƒt|ƒ}t|ƒ}||krLt|ƒdg||}ng|jD]}t|ƒt|ƒ^qV}gtt|ƒdƒD]}t||d ƒ^q}gtdg||dgƒD]\}}|||!^qÍ}gt|j|ƒD]} | dj | dŒ^qÿ} t | ŒS(s×Apply on a list of fields. If the number of input fields supplied is not equal to the order of the tensor product field, the list of arguments is padded with ``None``'s. The list of arguments is divided in sublists depending on the order of the forms inside the tensor product. The sublists are provided as arguments to these forms and the resulting expressions are given to the constructor of ``TensorProduct``. iiN( RmRnRhRBR\RcRtsumRAR•R›( Rtfieldst tot_orderttot_argsRxtordersR4tindicesR™REt multipliers((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRjRs   ,7=6(R#R$R%RR`Rj(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR›s1 t WedgeProductcB seZdZd„ZRS(sÙWedge product of forms. In the context of integration only completely antisymmetric forms make sense. The wedge product permits the creation of such forms. Examples ======== Use the predefined R2 manifold, setup some boilerplate. >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import WedgeProduct >>> WedgeProduct(R2.dx, R2.dy)(R2.e_x, R2.e_y) 1 >>> WedgeProduct(R2.dx, R2.dy)(R2.e_y, R2.e_x) -1 >>> WedgeProduct(R2.dx, R2.x*R2.dy)(R2.x*R2.e_x, R2.e_y) x**2 >>> WedgeProduct(R2.e_x,R2.e_y)(R2.y,None) -e_x You can nest wedge products. >>> wp1 = WedgeProduct(R2.dx, R2.dy) >>> WedgeProduct(wp1, R2.dx)(R2.e_x, R2.e_y, R2.e_x) 0 cG s¬d„|jDƒ}dtd„|DƒŒ}t|ƒ}d„tttt|ƒƒƒƒDƒ}t|jŒ}|tgt||ƒD]}||dŒ|d^q†ŒS(s|Apply on a list of vector_fields. The expression is rewritten internally in terms of tensor products and evaluated.cs s%|]}t|ƒt|ƒVqdS(N(RmRn(R~te((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys Œsics s|]}t|ƒVqdS(N(R(R~to((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys scs s!|]}t|ƒjƒVqdS(N(Rt signature(R~tp((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys si( R!R RRBRRhR›R RA(RR R£tmultpermst perms_part tensor_prodRª((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRjˆs "(R#R$R%Rj(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR¦hst LieDerivativecB s)eZdZd„Zd„Zd„ZRS(s•Lie derivative with respect to a vector field. The transport operator that defines the Lie derivative is the pushforward of the field to be derived along the integral curve of the field with respect to which one derives. Examples ======== >>> from sympy.diffgeom import (LieDerivative, TensorProduct) >>> from sympy.diffgeom.rn import R2 >>> LieDerivative(R2.e_x, R2.y) 0 >>> LieDerivative(R2.e_x, R2.x) 1 >>> LieDerivative(R2.e_x, R2.e_x) 0 The Lie derivative of a tensor field by another tensor field is equal to their commutator: >>> LieDerivative(R2.e_x, R2.e_r) Commutator(e_x, e_r) >>> LieDerivative(R2.e_x + R2.e_y, R2.x) 1 >>> tp = TensorProduct(R2.dx, R2.dy) >>> LieDerivative(R2.e_x, tp) LieDerivative(e_x, TensorProduct(dx, dy)) >>> LieDerivative(R2.e_x, tp) LieDerivative(e_x, TensorProduct(dx, dy)) cC sŽt|ƒ}t|ƒdks*t|ƒr9tdƒ‚n|dkratt|ƒj|||ƒS|jtƒr}t||ƒS|j |ƒSdS(NismLie derivatives are defined only with respect to vector fields. The supplied argument was not a vector field.i( RmRnRoR_R¯RRpRSR}R•(Rtv_fieldtexprt expr_form_ord((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRµs   cC s>tt|ƒjƒ||_||_|j|jf|_dS(N(R_R¯R`t_v_fieldt_exprRc(RR°R±((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR`Âs  c G s|j}|j}|||Œƒ}tgtt|ƒƒD]6}t|| t|||ƒf||dŒ^q:Œ}||S(Ni(R³R´R RRhR R}(RR!RR±t lead_termR4trest((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRjÈs   O(R#R$R%RR`Rj(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR¯•s tBaseCovarDerivativeOpcB s eZdZd„Zd„ZRS(sCovariant derivative operator with respect to a base vector. Examples ======== >>> from sympy.diffgeom.rn import R2, R2_r >>> from sympy.diffgeom import BaseCovarDerivativeOp >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct >>> TP = TensorProduct >>> ch = metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) >>> ch [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> cvd = BaseCovarDerivativeOp(R2_r, 0, ch) >>> cvd(R2.x) 1 >>> cvd(R2.x*R2.e_x) e_x cC sMtt|ƒjƒ||_||_||_|j|j|jf|_dS(N(R_R·R`RaRft _christoffelRc(RRdRgt christoffel((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR`äs    cC sÆt|ƒdkrtƒ‚nt||jƒ}|jj|jƒ}|jj|jƒ}t|jt ƒƒ}gt |ƒD]"\}}t d|ƒ|ƒ^q|}|j tt ||ƒƒƒ}||ƒ}|j tt ||ƒƒƒ}g} xl|D]d} tgt| jjƒD]2} |j| |j| jf| jj| ƒ^qŒ} | j| ƒqùWg|D]} || ƒ^qh} |j tt | | ƒƒƒ}|j tt ||ƒƒƒ}|jƒS(sÎApply on a scalar field. The action of a vector field on a scalar field is a directional differentiation. If the argument is not a scalar field the behaviour is undefined. is_#_%s(RmRHtvectors_in_basisRaRTRfRQRBRpRSRqRRIRAR RRR¸R(Ri(Rtfieldt wrt_vectort wrt_scalartvectorsR4RuRvRwtderivsRR—tdtto_subsR|((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRjës( 2  K(R#R$R%R`Rj(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR·Ñs tCovarDerivativeOpcB s)eZdZd„Zd„Zd„ZRS(sñCovariant derivative operator. Examples ======== >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import CovarDerivativeOp >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct >>> TP = TensorProduct >>> ch = metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) >>> ch [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> cvd = CovarDerivativeOp(R2.x*R2.e_x, ch) >>> cvd(R2.x) x >>> cvd(R2.x*R2.e_x) x*e_x cC s¢tt|ƒjƒttd„|jtƒDƒƒƒdkrJtƒ‚nt|ƒdksht |ƒrwt dƒ‚n||_ ||_ |j |j f|_ dS(Ncs s|]}|jVqdS(N(Ra(R~R((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys ,sissCovariant derivatives are defined only with respect to vector fields. The supplied argument was not a vector field.(R_RÂR`RhRlRpRSRHRnRmRot_wrtR¸Rc(RtwrtR¹((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR`*s+   cC snt|jjtƒƒ}g|D]!}t|j|j|jƒ^q}|jjtt ||ƒƒƒj |ƒS(N( RBRÃRpRSR·RaRfR¸RIRAR•(RR»R¾Rtbase_ops((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRj6s+cG sd|j|jƒS(Ns\mathbb{\nabla}_{%s}(t_printRÃ(RR R!((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR"<s(R#R$R%R`RjR"(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRÂs ic  sätˆƒdkstˆƒr-tdƒ‚n‡fd†‰‡‡‡‡fd†}|r`|nˆj}|jƒ}g|D]}||ƒ^q|} |r½gt| ŒD]} t| ƒ^q§Stg| D]} t| ƒ^qǃSdS(sm Return the series expansion for an integral curve of the field. Integral curve is a function `\gamma` taking a parameter in `R` to a point in the manifold. It verifies the equation: `V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big)` where the given ``vector_field`` is denoted as `V`. This holds for any value `t` for the parameter and any scalar field `f`. This equation can also be decomposed of a basis of coordinate functions `V(f_i)\big(\gamma(t)\big) = \frac{d}{dt}f_i\big(\gamma(t)\big) \quad \forall i` This function returns a series expansion of `\gamma(t)` in terms of the coordinate system ``coord_sys``. The equations and expansions are necessarily done in coordinate-system-dependent way as there is no other way to represent movement between points on the manifold (i.e. there is no such thing as a difference of points for a general manifold). See Also ======== intcurve_diffequ Parameters ========== vector_field the vector field for which an integral curve will be given param the argument of the function `\gamma` from R to the curve start_point the point which corresponds to `\gamma(0)` n the order to which to expand coord_sys the coordinate system in which to expand coeffs (default False) - if True return a list of elements of the expansion Examples ======== Use the predefined R2 manifold: >>> from sympy.abc import t, x, y >>> from sympy.diffgeom.rn import R2, R2_p, R2_r >>> from sympy.diffgeom import intcurve_series Specify a starting point and a vector field: >>> start_point = R2_r.point([x, y]) >>> vector_field = R2_r.e_x Calculate the series: >>> intcurve_series(vector_field, t, start_point, n=3) Matrix([ [t + x], [ y]]) Or get the elements of the expansion in a list: >>> series = intcurve_series(vector_field, t, start_point, n=3, coeffs=True) >>> series[0] Matrix([ [x], [y]]) >>> series[1] Matrix([ [t], [0]]) >>> series[2] Matrix([ [0], [0]]) The series in the polar coordinate system: >>> series = intcurve_series(vector_field, t, start_point, ... n=3, coord_sys=R2_p, coeffs=True) >>> series[0] Matrix([ [sqrt(x**2 + y**2)], [ atan2(y, x)]]) >>> series[1] Matrix([ [t*x/sqrt(x**2 + y**2)], [ -t*y/(x**2 + y**2)]]) >>> series[2] Matrix([ [t**2*(-x**2/(x**2 + y**2)**(3/2) + 1/sqrt(x**2 + y**2))/2], [ t**2*x*y/(x**2 + y**2)**2]]) is*The supplied field was not a vector field.c std„ˆg||ƒS(s=Return ``vector_field`` called `i` times on ``scalar_field``.cS s |j|ƒS(N(R•(tsR((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyt¨t(R(RrR4(t vector_field(s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyt iter_vfield¦sc sAgtˆƒD]0}ˆ|ˆ||ƒjˆƒt|ƒ^q S(s-Return the series for one of the coordinates.(RR•R(RQR4(RËR5tparamt start_point(s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyttaylor_terms_per_coordªsN(RnRmRoRaRRRARRŸ( RÊRÌRÍR5RdtcoeffsRÎRRRxt taylor_termsRERš((RËR5RÌRÍRÊs6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pytintcurve_seriesCs` #c C s$t|ƒdkst|ƒr-tdƒ‚n|r9|n|j}gt|jjƒD]}td|ƒ|ƒ^qU}t||ƒ}|jƒ}g|D]:}t t |j |ƒ|ƒ|j |ƒj |ƒƒ^q™} g|D]4}t |j |ƒj |dƒ|j |ƒƒ^qà} | | fS(sReturn the differential equation for an integral curve of the field. Integral curve is a function `\gamma` taking a parameter in `R` to a point in the manifold. It verifies the equation: `V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big)` where the given ``vector_field`` is denoted as `V`. This holds for any value `t` for the parameter and any scalar field `f`. This function returns the differential equation of `\gamma(t)` in terms of the coordinate system ``coord_sys``. The equations and expansions are necessarily done in coordinate-system-dependent way as there is no other way to represent movement between points on the manifold (i.e. there is no such thing as a difference of points for a general manifold). See Also ======== intcurve_series Parameters ========== vector_field the vector field for which an integral curve will be given param the argument of the function `\gamma` from R to the curve start_point the point which corresponds to `\gamma(0)` coord_sys the coordinate system in which to give the equations Returns ======= a tuple of (equations, initial conditions) Examples ======== Use the predefined R2 manifold: >>> from sympy.abc import t >>> from sympy.diffgeom.rn import R2, R2_p, R2_r >>> from sympy.diffgeom import intcurve_diffequ Specify a starting point and a vector field: >>> start_point = R2_r.point([0, 1]) >>> vector_field = -R2.y*R2.e_x + R2.x*R2.e_y Get the equation: >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point) >>> equations [f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)] >>> init_cond [f_0(0), f_1(0) - 1] The series in the polar coordinate system: >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p) >>> equations [Derivative(f_0(t), t), Derivative(f_1(t), t) - 1] >>> init_cond [f_0(0) - 1, f_1(0) - pi/2] is*The supplied field was not a vector field.sf_%di( RnRmRoRaRRRRYRRRR R•RI( RÊRÌRÍRdR4tgammast arbitrary_pRRtcft equationst init_cond((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pytintcurve_diffequ·sE/ D>cC srtg|D]}|jƒ^q ƒ}tt||ƒƒ}tg|D]}t|ƒj|ƒ^qDƒ}||fS(N(RR@R?RAR RI(R!texprsRÇtd_argstrepsR±td_exprs((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyR6 s%.cC s„t|tƒr`g|jD]}t|ƒ^q}tt|ƒƒdkrXtdƒ‚n|dSt|tƒrég|jD]}t|ƒ^qy}g|D]}|dkr˜|^q˜}t|ƒdkr×tdƒ‚n|sádS|dSt|tƒr)t |j ƒst |j ƒr%tdƒ‚ndSt|t ƒr<dSt|t ƒrbtd„|jDƒƒS| sx|jtƒr|dSdSdS( s_Return the contravariant order of an expression. Examples ======== >>> from sympy.diffgeom import contravariant_order >>> from sympy.diffgeom.rn import R2 >>> from sympy.abc import a >>> contravariant_order(a) 0 >>> contravariant_order(a*R2.x + 2) 0 >>> contravariant_order(a*R2.x*R2.e_y + R2.e_x) 1 isFMisformed expression containing contravariant fields of varying order.is?Misformed expression containing multiplication between vectors.s4Misformed expression containing a power of a vector.cs s|]}t|ƒVqdS(N(Rn(R~R“((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys >siÿÿÿÿN(R,R R!RnRhRlRoR R RmtbasetexpRSR›RŸRpRO(R±t_strictR§R£R¨tnot_zero((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRns.""% cC s‘t|tƒr`g|jD]}t|ƒ^q}tt|ƒƒdkrXtdƒ‚n|dSt|tƒrég|jD]}t|ƒ^qy}g|D]}|dkr˜|^q˜}t|ƒdkr×tdƒ‚n|sádS|dSt|tƒr)t|j ƒst|j ƒr%tdƒ‚ndSt|t ƒrIt|jŒdSt|t ƒrot d„|jDƒƒS| s…|jtƒr‰dSdSdS( sIReturn the covariant order of an expression. Examples ======== >>> from sympy.diffgeom import covariant_order >>> from sympy.diffgeom.rn import R2 >>> from sympy.abc import a >>> covariant_order(a) 0 >>> covariant_order(a*R2.x + 2) 0 >>> covariant_order(a*R2.x*R2.dy + R2.dx) 1 is=Misformed expression containing form fields of varying order.is=Misformed expression containing multiplication between forms.s2Misformed expression containing a power of a form.cs s|]}t|ƒVqdS(N(Rm(R~R“((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pys ksiÿÿÿÿN(R,R R!RmRhRlRoR R RÜRÝRVR›RŸRpRO(R±RÞR§R£R¨Rß((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRmEs.""% cC s–t|jtƒƒ}g}x\|D]T}|j}|j||jƒƒ}|jt|jƒƒ|j }|j |ƒq"W|j tt ||ƒƒƒS(sñTransform all base vectors in base vectors of a specified coord basis. While the new base vectors are in the new coordinate system basis, any coefficients are kept in the old system. Examples ======== >>> from sympy.diffgeom import vectors_in_basis >>> from sympy.diffgeom.rn import R2_r, R2_p >>> vectors_in_basis(R2_r.e_x, R2_p) x*e_r/sqrt(x**2 + y**2) - y*e_theta/(x**2 + y**2) >>> vectors_in_basis(R2_p.e_r, R2_r) sin(theta)*e_y + cos(theta)*e_x ( RBRpRSRaRMRRtTRRURfR(RIRA(R±R9R¾t new_vectorsRtcsR{tnew((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRºus   cC sÃt|ƒdkst|ƒr-tdƒ‚n|jtƒ}t|ƒdkr]tdƒ‚n|jƒ}|jƒ}|jƒ}g|D]+}g|D]}|j ||ƒ^q•^qˆ}t |ƒS(sèReturn the matrix representing the twoform. For the twoform `w` return the matrix `M` such that `M[i,j]=w(e_i, e_j)`, where `e_i` is the i-th base vector field for the coordinate system in which the expression of `w` is given. Examples ======== >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import twoform_to_matrix, TensorProduct >>> TP = TensorProduct >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) Matrix([ [1, 0], [0, 1]]) >>> twoform_to_matrix(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) Matrix([ [x, 0], [0, 1]]) >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy) - TP(R2.dx, R2.dy)/2) Matrix([ [ 1, 0], [-1/2, 1]]) is'The input expression is not a two-form.isThe input expression concerns more than one coordinate systems, hence there is no unambiguous way to choose a coordinate system for the matrix.( RmRnRoRpR+RhtpopRUR‚R•R(R±RdR¾R…R„tmatrix_content((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyttwoform_to_matrix’s   5c  st|ƒ}|jƒs'tdƒ‚n|jtƒjƒ}g|jƒD]‰|j‡fd†ƒ^qI}tt |j ƒƒ}g|D]h}g|D]U}g|D]B}||||f||||f||||fd^q£^q–^q‰}t |ƒS(sXReturn the nested list of Christoffel symbols for the given metric. This returns the Christoffel symbol of first kind that represents the Levi-Civita connection for the given metric. Examples ======== >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Christoffel_1st, TensorProduct >>> TP = TensorProduct >>> metric_to_Christoffel_1st(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> metric_to_Christoffel_1st(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[1/2, 0], [0, 0]], [[0, 0], [0, 0]]] s6The two-form representing the metric is not symmetric.c s ˆ|ƒS(N((R“(RÀ(s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pyRÈÓRÉi( Ræt is_symmetricRoRpR+RäRUt applyfuncRBRRR( R±tmatrixRdtderiv_matricesR¤R4R™R—R¹((RÀs6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pytmetric_to_Christoffel_1st¼s   .rc C s@t|ƒ}|jtƒjƒ}tt|jƒƒ}t|ƒ}tƒ}x$|D]}|j |jt ƒƒqRWt|ƒ}|j }|j tt ||ƒƒƒjƒj tt ||ƒƒƒ}g|D]f}g|D]S} g|D]@} tg|D]'} ||| f|| | | f^qôŒ^qä^q×^qÊ} t| ƒS(s]Return the nested list of Christoffel symbols for the given metric. This returns the Christoffel symbol of second kind that represents the Levi-Civita connection for the given metric. Examples ======== >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct >>> TP = TensorProduct >>> metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[0, 0], [0, 0]], [[0, 0], [0, 0]]] >>> metric_to_Christoffel_2nd(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[1/(2*x), 0], [0, 0]], [[0, 0], [0, 0]]] (RëRpR+RäRBRRRæRltupdateROR1RIRAtinvR R( R±tch_1stRdR¤Réts_fieldsR§tdumsR4R™R—tlR¹((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pytmetric_to_Christoffel_2ndÝs      <pcC sBt|ƒ}|jtƒjƒ}tt|jƒƒ}g|D]^}g|D]K}g|D]8}g|jƒD]}|||||fƒ^qj^qW^qJ^q=}g|D]i} g|D]V} g|D]C} g|D]0} || | | | || | | | ^qÏ^qÂ^qµ^q¨} g|D]ž} g|D]‹} g|D]x} g|D]e} tg|D]L}|| || f||| | f|| || f||| | f^qUŒ^qE^q8^q+^q}g|D]i} g|D]V} g|D]C} g|D]0} | | | | | || | | | ^qð^qã^qÖ^qÉ}t |ƒS(s Return the components of the Riemann tensor expressed in a given basis. Given a metric it calculates the components of the Riemann tensor in the canonical basis of the coordinate system in which the metric expression is given. Examples ======== >>> from sympy import exp >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Riemann_components, TensorProduct >>> TP = TensorProduct >>> metric_to_Riemann_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[[[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]] >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + R2.r**2*TP(R2.dtheta, R2.dtheta) >>> non_trivial_metric r**2*TensorProduct(dtheta, dtheta) + exp(2*r)*TensorProduct(dr, dr) >>> riemann = metric_to_Riemann_components(non_trivial_metric) >>> riemann[0, :, :, :] [[[0, 0], [0, 0]], [[0, r*exp(-2*r)], [-r*exp(-2*r), 0]]] >>> riemann[1, :, :, :] [[[0, -1/r], [1/r, 0]], [[0, 0], [0, 0]]] ( RòRpR+RäRBRRRUR R(R±tch_2ndRdR¤R4R™R—RÀtderiv_chtrhotsigtmutnut riemann_aRñt riemann_btriemann((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pytmetric_to_Riemann_componentss hs¨sc C s•t|ƒ}|jtƒjƒ}tt|jƒƒ}g|D]H}g|D]5}tg|D]}|||||f^qZŒ^qJ^q=}t|ƒS(sOReturn the components of the Ricci tensor expressed in a given basis. Given a metric it calculates the components of the Ricci tensor in the canonical basis of the coordinate system in which the metric expression is given. Examples ======== >>> from sympy import exp >>> from sympy.diffgeom.rn import R2 >>> from sympy.diffgeom import metric_to_Ricci_components, TensorProduct >>> TP = TensorProduct >>> metric_to_Ricci_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy)) [[0, 0], [0, 0]] >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + R2.r**2*TP(R2.dtheta, R2.dtheta) >>> non_trivial_metric r**2*TensorProduct(dtheta, dtheta) + exp(2*r)*TensorProduct(dr, dr) >>> metric_to_Ricci_components(non_trivial_metric) [[1/r, 0], [0, r*exp(-2*r)]] ( RüRpR+RäRBRRR R(R±RûRdR¤R4R™R—tricci((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pytmetric_to_Ricci_components:s  RN(=t __future__RRt itertoolsRtsympy.combinatoricsRt sympy.coreRRRRRR R R R R RRtsympy.core.compatibilityRRtsympy.core.numbersRtsympy.functionsRtsympy.matricesRtsympy.simplifyRt sympy.solversRtsympy.tensor.arrayRRR&R+RYRORSR}RVR›R¦R¯R·RÂR\R]RÑR×R6RnRmRºRæRëRòRüRþ(((s6lib/python2.7/site-packages/sympy/diffgeom/diffgeom.pytsFR,ÿ<TlIqV-<E-t V - 0  * ! ' 6