Updates to the DifferentialGeometry Package in Maple 15 - Maple Programming Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : System : Information : Updates : Maple 15 : updates/Maple15/differentialgeometry

Updates to the DifferentialGeometry Package in Maple 15

Overview

• 

In the DifferentialGeometry package, 17 new commands have been added, most of them supporting advanced computations in general relativity, and there is increased functionality for many of the previously existing commands. Mainly:

– 

In the Tensor subpackage, 13 new commands have been added. These are: AdaptedNullTetrad, AdaptedSpinorDyad, ConformalKillingVectors, CovariantlyConstantTensors, FactorWeylSpinor, HomothetyVectors, KillingSpinors, KillingYanoTensors, NullVector, PlebanskiTensor, PrincipalNullDirections, RecurrentTensors and TraceFreeRicciTensor. Six other commands have new simpler calling sequences and/or have more flexibility accepting optional arguments.

– 

In the GroupActions subpackage there are two new commands, InfinitesimalPseudoGroupNormalizer and MatrixGroup.

– 

In the LieAlgebras subpackage, two new commands are InfinitesimalCoadjointAction and MatrixNormalizer.

• 

With this extension of the DifferentialGeometry functionality and a small reorganization of the commands within the Tensor subpackage, in Maple 15 the package's structure is as follows:

– 

DifferentialGeometry contains 33 commands and 6 subpackages: GroupActions, JetCalculus, Library, LieAlgebras, Tensor, and Tools.

– 

The GroupActions subpackage, for working with Lie groups and infinitesimal transformations, contains 10 commands and 1 subpackage, MovingFrames, in turn with 2 commands.

– 

The JetCalculus subpackage, for working in jet spaces, in calculus of variations and with differential equations, contains 22 commands.

– 

The Library subpackage, for browsing and searching tables of Lie algebras and differential equations, contains 4 commands.

– 

The LieAlgebras subpackage, for defining Lie algebras from a variety of sources and creating new ones, contains 33 commands and 2 subpackages, LieAlgebraCohomology and LieAlgebraRepresentations, with respectively 4 and 11 commands.

– 

The Tensor subpackage, for computations with tensors on the tangent bundle of any manifold or with tensors on any vector bundle, with specialized functionality for advanced general relativity, contains 79 commands.

– 

The Tools subpackage, with utility procedures for developing new differential geometry applications, contains 20 commands and one subpackage, DGmain, with 7 commands.

  

All in all, the Maple 15 DifferentialGeometry package is the most resourceful mathematical software available for the area, with over 220 commands covering a wide range of topics, from basic jet calculus to the realm of the mathematics behind general relativity, thorough documentation for all of its commands, 19 differential geometry Lessons from beginner to advanced level and 5 Tutorials illustrating the use of the package in applications.

Description of New DifferentialGeometry Functionality

• 

Two-component spinors and the Newman-Penrose formalism

– 

Powerful new commands for the 2-component spinor and Newman-Penrose formalisms for general relativity are provided: AdaptedNullTetrad, AdaptedSpinorDyad, FactorWeylSpinor, and PrincipalNullDirections. Adapted null tetrads are a preferred basis of null vectors in which the components of the curvature tensor of space-time, expressed via the Newman-Penrose formalism, achieve a particularly simple form. Adapted null tetrads can be used to simplify subsequent computations and play an important role in the equivalence problem in relativity. Likewise, the principal null directions give a set of preferred null directions in space-time which are very important to the study of the geometric properties of that spacetime.

– 

New calling sequences for NPCurvatureScalars and WeylSpinor provide added flexibility for computations with spinors.

– 

The classification of spacetimes depending on parameters (case-splitting) is now possible with the command PetrovType.

• 

Special Geometric Fields

– 

Special classes of vectors, tensors and spinors can now be calculated with the new commands ConformalKillingVectors, CovariantlyConstantTensors, KillingSpinors, KillingYanoTensors, and RecurrentTensors.

– 

The calling sequences for the existing commands KillingTensors and KillingVectors have been extended so that all these commands for finding special fields have a uniform syntax.

– 

You can specify an ansatz to use to find these special tensors.

– 

Case-splitting may be invoked with each command.

• 

New tensors and utilities

– 

The new NullVector, PlebanskiTensor, and TraceFreeRicciTensor provide implementations of the formulas for these tensors.

– 

Tests for checking principal null directions and recurrent tensor are now available with GRQuery.

• 

Integration of the subpackage Killing

– 

The subpackage Tensor[Killing] has been deprecated and the 6 commands that were contained in the Killing subpackage [CheckKillingTensor, IndependentKillingTensors, KillingBracket, KillingTensors, KillingVectors, and SymmetricProductsOfKillingTensors] have been integrated directly into the Tensor subpackage.

• 

Matrix Lie algebras

– 

The commands BracketOfSubspaces and MinimalSubalgebra now accept lists of matrices as arguments.

– 

The new command MatrixNormalizer commutes the normalizer of a set of matrices within a given Lie algebra.

– 

With these new commands (and others from prior releases) the LieAlgebras subpackage now provides good basic support for working directly with matrix algebras.

• 

Vector field representation of Lie algebras

– 

The new command InfinitesimalCoadjointAction calculates the standard vector field representation of a Lie algebra in terms of the structure constants.

• 

Vector field normalizers

– 

The new command InfinitesimalPseudoGroupNormalizer will calculate the normalizer of a finite dimensional Lie algebra of vector fields within an infinite dimensional Lie algebra of vector fields, as parametrized by arbitrary functions. The command can be used, for example, in studying reductions of the Einstein equations.

• 

Matrix groups and Lie groups

– 

The command MatrixGroup will calculate the matrix group for a given matrix Lie algebra.

– 

The command LieGroup has 2 new calling sequences which allow you to construct a Lie group module from [i] an r-transformation group or [ii] the explicit multiplication map defining the Lie group.

• 

Invariant tensors

– 

The calling sequences for the commands InvariantGeometricObjectFields and InfinitesimalSymmetriesOfGeometricObjectFields have been extended to match those used to compute special geometric fields.

– 

Case-splitting can be invoked with either of these commands.

– 

Invariant tensor fields on Lie algebras can now be computed with InvariantGeometricObjectFields. Case-splitting can be invoked.

• 

Database of solutions to the Einstein equations

– 

Space-time metrics, together with many of their properties, can now be automatically loaded into a Maple worksheet with the Retrieve command.

Examples Illustrating New Functionality

Special Tensors

• 

Killing tensors, Killing-Yano tensors, Killing spinors, covariantly constant tensors, and recurrent tensors are examples of tensors which are defined as solutions to certain over-determined systems of linear partial differential equations. The DifferentialGeometry package generates these PDE systems; these equations are solved by pdsolve, and the solutions are re-expressed as tensor fields of the appropriate type.

• 

We define a metric g on a manifold M and calculate the covariantly constant 1-forms, the rank 2 Killing tensors, and the rank 2 Killing-Yano tensors.

with(DifferentialGeometry): with(Tensor):

DGsetup([x, y, z], M);

frame name: M

(1)

g := evalDG(dx &t dx + dy &t dy + x^3*dz &t dz);

gdx+_noncommutativedx+3_noncommutative+dy+_noncommutativedy+x3dz+_noncommutativedz

(2)

CurvatureTensor(g);

3xD_x4+_noncommutativedz+_noncommutativedx+_noncommutativedz+3xD_x4+_noncommutativedz+_noncommutativedz+_noncommutativedx+3D_z4x2+_noncommutativedx+_noncommutativedx+_noncommutativedz3D_z4x2+_noncommutativedx+_noncommutativedz+_noncommutativedx

(3)

CovariantlyConstantTensors(g, [dx, dy, dz]);

dy+_noncommutative

(4)

KillingTensors(g, 2);

dy+_noncommutativedy+_noncommutative,ydx+_noncommutativedxxdx2+_noncommutativedyxdy2+_noncommutativedx+x3zdy4+_noncommutativedz+x3zdz4+_noncommutativedy+2_noncommutative+yx3dz+_noncommutativedz,dx+_noncommutativedx+2_noncommutative+x3dz+_noncommutativedz,x3dy2+_noncommutativedz+2_noncommutative+x3dz2+_noncommutativedy,x6dz+_noncommutativedz+_noncommutative

(5)

KillingYanoTensors(g, 2);

x32dx+_noncommutative`^`dz+_noncommutative

(6)

Principal Null Directions

• 

The principal null directions of a space-time are preferred directions determined by rather complicated nonlinear algebraic equations formed from the Weyl tensor of the space-time metric g.

• 

The new command PrincipalNullDirections uses the two-component spinor formalism of the DifferentialGeometry package to calculate principal null direction via the new command AdaptedSpinorDyad.

with(DifferentialGeometry): with(Tensor):

DGsetup([t, x, y, z], M);

frame name: M

(7)
• 

Define a metric and a null tetrad for the metric.

g := evalDG(dx &t dx + dy &t dy + 1/2*exp(2*x)*dz &t dz - 1/2*(dt + exp(x)*dz) &s (dt + exp(x)*dz));

gdt2+_noncommutativedtⅇxdt2+_noncommutativedz+dx+_noncommutativedx+dy+_noncommutativedyⅇxdz2+_noncommutativedt_noncommutative

(8)

NT := evalDG([-(1/2)*sqrt(2)*(sqrt(2)-1)*D_t+exp(-x)*D_z, (1/2)*sqrt(2)*(1+sqrt(2))*D_t-exp(-x)*D_z, (1/2)*sqrt(2)*D_x+(1/2*I)*sqrt(2)*D_y, (1/2)*sqrt(2)*D_x-(1/2*I)*sqrt(2)*D_y]);

NT221D_t2+ⅇxD_z,21+2D_t2ⅇxD_z,2D_x2+2_noncommutative+I2D_y2,2D_x2I2D_y2

(9)
• 

Find the Petrov type of the metric -- this is needed in order to determine the number of principal null directions and the algorithm which will be used to calculate them.

PetrovType(NT);

D

(10)
• 

For type "D" space-times there are always two principal null directions.

PND := PrincipalNullDirections(NT, "D");

PND2D_tI2RootOf_Z2+1D_y,2D_t4+2_noncommutative+I2RootOf_Z2+1D_y4

(11)

allvalues(PND)[1];

2D_t+2_noncommutative+2D_y,2D_t42D_y4

(12)

Case Splitting with PetrovType

• 

For four-dimensional space-times, the Petrov type is a fundamental invariant which provides important information about the geometric properties of the space. The possible Petrov types are ["I", "II", "III", "D", "N", "O"]. If the metric depends upon parameters (either constants or functions), then the Petrov type can change for exceptional values of these parameters.

• 

New keyword arguments for the command PetrovType make it now possible to identity these exceptional values.

with(DifferentialGeometry): with(Tensor):

DGsetup([u, v, y, z], M);

frame name: M

(13)
• 

We define a metric depending upon 2 parameters p,q.

g := evalDG(1/y^(2)*(dy &t dy   - du &s dv ) + y^(2*p)*dz &t dz  +  y^(2*q) *dv &t dv);

gdu2y2+_noncommutativedvdv2y2+_noncommutativedu+y2qdv+_noncommutativedv+dyy2+_noncommutativedy+y2pdz+_noncommutativedz+_noncommutative

(14)
• 

Here is a null tetrad we shall use to calculate the Petrov type of the metric g.

NT := evalDG([y*D_u, (1/2)*y^(3+2*q)*D_u + y*D_v, (1/2)*sqrt(2)*y*D_y + (1/2*I)*sqrt(2)*y^(-p)*D_z, (1/2)*sqrt(2)*y*D_y - (1/2*I)*sqrt(2)*y^(-p)*D_z]);

NTyD_u+_noncommutative,y3+2qD_u2+2_noncommutative+yD_v,2yD_y2+2_noncommutative+I2ypD_z2,2yD_y2I2ypD_z2

(15)
• 

We find that this metric is of Petrov type "I" for generic values of the parameters p,q. There are exceptional values leading to space-times of Petrov type "N", "D", "O".

PetrovType(NT, parameters = [p, q]);

tableIII=,I=,D=p=2q,q=q,II=generic,O=p=−1,q=12,p=0,q=0,N=p=−1,p=0,p=−1,q=q,p=0,q=q

(16)
• 

With the keyword argument auxiliaryequations, additional constraints can be imposed upon the parameters.

PetrovType(NT, auxiliaryequations = [p^2 + q^2 = 4], parameters = [p, q]);

tableIII=,I=,D=p=455,q=255,p=455,q=255,II=generic,O=,N=p=−1,q=3,p=−1,q=3,p=−1,q=RootOf_Z23,p=0,q=−2,p=0,q=2

(17)

Case Splitting with KillingVectors

• 

We first define a simple class of metrics in two dimensions, depending upon a parameter k.

DGsetup([x, y], M);

frame name: M

(18)

g := evalDG(y^k*( dx &t dx + dy &t dy));

gykdx+_noncommutativedx+2_noncommutative+ykdy+_noncommutativedy

(19)
• 

When k=0, this metric is the standard flat metric in the plane and therefore admits a three-dimensional group of isometries -- with infinitesimal generators or Killing vectors x,y,yxxy.

• 

When k=2, this becomes the well-known metric for the Poincare half-plane and again there are 3 Killing vectors.

• 

For other values of k, there is an obvious Killing vector x.

• 

We can use the KillingVectors command, with the keyword argument parameter, to calculate the Killing vectors for this metric and to determine both the generic and exceptional cases. We see that the well-known cases we just mentioned are the only exceptional ones.

KillingVectors(g, parameters = {k});

yD_x+xD_y,D_y+_noncommutative,D_x+_noncommutative,x22y22D_x+2_noncommutative+yxD_y,xD_x+2_noncommutative+yD_y,D_x+_noncommutative,D_x+_noncommutative,k=0,k=−2,k=k

(20)

Minimal Subalgebras of Matrices

• 

The command MinimalSubalgebras has been extended to work with matrices. Given a list of matrices A, this command with calculate the smallest list of matrices which contains A and which is closed under the operation of matrix commutation.

with(DifferentialGeometry): with(LieAlgebras):

A := [Matrix([[1, 0, 0], [0, 1, 0], [1, 0, 0]]), Matrix([[0, 1, 0], [0, 1, 1], [0, 1, 0]])];

A100010100,010011010

(21)

B := MinimalSubalgebra(A);

B100010100,010011010,000−101000,−101−101−101

(22)

Matrix Groups

• 

Given a matrix algebra, as defined by a list of matrices A which are closed under matrix commutation, the corresponding matrix group can be calculated by taking the matrix exponential of a general linear combination of the elements of A. The result is usually rather complicated and not so useful for subsequently analysis. The command MatrixGroup will use some simple heuristics to simplify the expression for the matrix group.

with(DifferentialGeometry): with(LieAlgebras): with(Library): with(GroupActions):

A1 := Matrix([[0, 0, 1, 0], [0, 0, 0, -1], [0, 0, 0, 0], [0, 0, 0, 0]]):

A2 := Matrix([[0, 0, 0, 1], [0, 0, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0]]):

A3 := Matrix([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]):

A4 := Matrix([[0, -1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]):

A := [A1, A2, A3, A4];

A0010000−100000000,0001001000000000,−10000−10000000000,0−100100000000000

(23)

B, Id := MatrixGroup(A, [u, v, x, y]);

B,Idcosuvsinuvyxsinuvcosuvxy00100001,u=0,v=1,x=0,y=0

(24)
• 

The 4-parameter family of matrices B is closed under matrix multiplication and matrix inversions. The value of the parameters which define the identity is also given.

Lie Groups

• 

The DifferentialGeometry package uses a Maple module to represent a general Lie group. The exports of the module are LeftMultiplication, RightMultiplication, Inverse, and Identity. These provide the basic operations for performing computations with Lie groups.

• 

The command LieGroup uses various scenarios construct this Maple module. For Maple 15, new calling sequences for the LieGroup command has been added to include other common situations. In this example, we consider a 5 parameter group of affine transformations in the plane and use the LieGroup command to construct the abstract Lie group defined by this transformation group.

with(DifferentialGeometry): with(GroupActions):

DGsetup([x, y], M);

frame name: M

(25)

DGsetup([a, b, c, d, e], G);

frame name: G

(26)

T := Transformation(M, M, [x = a*x + b*y +c, y = d*y + e]);

Tx=ax+by+c,y=dy+e

(27)

LG := LieGroup(T, G);

LG:=moduleexportFrame,Identity,LeftMultiplication,RightMultiplication,Inverse;end module

(28)

LG:-LeftMultiplication([alpha, beta, gamma, delta, epsilon]);

a=αa,b=αb+βd,c=αc+βe+γ,d=δd,e=δe+ε

(29)

Invariant Tensor Fields on Lie Algebras

• 

The functionality of the command InvariantGeometricObjectFields has been extended to an algebraic setting to allow for the calculation of invariant tensors on Lie algebras.

• 

In this example, we shall create a 4-dimensional Lie algebra and calculate the symmetric rank 2 tensors on this algebra which are invariant with respect to a one-dimensional subalgebra.

with(DifferentialGeometry): with(LieAlgebras): with(GroupActions): with(Tensor):

• 

We use an array of structure constants to initialize our Lie algebra.

C := Array(1..4, 1..4, 1..4, {(1,2,1) = -1, (2,1,1) = 1, (1,3,2)  = -1, (1,2,3) =1, (2,3,3) = -1}):

L := LieAlgebraData(C, Alg);

Le1,e2=e1+e3,e1,e3=e2,e2,e3=e3

(30)

DGsetup(L):

• 

We find the most general rank 2, contravariant, symmetric tensor on the Lie algebra involving the vectors e2,e3,e4 and invariant with respect to e1.

Q := GenerateSymmetricTensors([e2, e3, e4],2);

Qe2+_noncommutativee2+_noncommutative,e22+_noncommutativee3+2_noncommutative+e32+_noncommutativee2,e22+_noncommutativee4+2_noncommutative+e42+_noncommutativee2,e3+_noncommutativee3+_noncommutative,e32+_noncommutativee4+2_noncommutative+e42+_noncommutativee3,e4+_noncommutativee4+_noncommutative

(31)

InvariantGeometricObjectFields([e1], Q, output = "list");

e4+_noncommutativee4+_noncommutative

(32)
• 

We find the most general rank 2, covariant symmetric tensor on the Lie algebra involving the dual vectors (or 1-forms) θ2,θ3,θ4 and invariant with respect to e1.

Q := GenerateSymmetricTensors([theta2, theta3, theta4], 2);

Qθ2+_noncommutativeθ2+_noncommutative,θ22+_noncommutativeθ3+2_noncommutative+θ32+_noncommutativeθ2,θ22+_noncommutativeθ4+2_noncommutative+θ42+_noncommutativeθ2,θ3+_noncommutativeθ3+_noncommutative,θ32+_noncommutativeθ4+2_noncommutative+θ42+_noncommutativeθ3,θ4+_noncommutativeθ4+_noncommutative

(33)

InvariantGeometricObjectFields([e1], Q, output = "list");

θ2+_noncommutativeθ2+2_noncommutative+θ3+_noncommutativeθ3,θ4+_noncommutativeθ4+_noncommutative

(34)

Retrieve

• 

With the new database of solutions to the Einstein equations it is now possible to use the Retrieve command to automatically load into a worksheet known solutions, taken from the general relativity literature.

with(DifferentialGeometry): with(Library):

DGsetup([t, x, y, z], M);

frame name: M

(35)

Retrieve("Stephani", 1, [12, 14, 1], manifoldname = M, output = ["Fields"]);

ⅇxcos3xdt_k2+_noncommutativedtⅇxsin3xdt_k2+_noncommutativedz+dx_k2+_noncommutativedx+ⅇ2xdy_k2+_noncommutativedyⅇxsin3xdz_k2+_noncommutativedt+ⅇxcos3xdz_k2+_noncommutativedz

(36)

See Also

Index of New Maple 15 Features