|
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.
|
•
|
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:
|
–
|
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 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.
|
–
|
The classification of spacetimes depending on parameters (case-splitting) is now possible with the command PetrovType.
|
•
|
Special Geometric Fields
|
–
|
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
|
–
|
Tests for checking principal null directions and recurrent tensor are now available with GRQuery.
|
•
|
Integration of the subpackage Killing
|
–
|
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.
|
–
|
Case-splitting can be invoked with either of these commands.
|
•
|
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 on a manifold and calculate the covariantly constant 1-forms, the rank 2 Killing tensors, and the rank 2 Killing-Yano tensors.
|
>
|
with(DifferentialGeometry): with(Tensor):
|
>
|
g := evalDG(dx &t dx + dy &t dy + x^3*dz &t dz);
|
| (2) |
| (3) |
>
|
CovariantlyConstantTensors(g, [dx, dy, dz]);
|
| (5) |
>
|
KillingYanoTensors(g, 2);
|
|
|
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 .
|
>
|
with(DifferentialGeometry): with(Tensor):
|
>
|
DGsetup([t, x, y, z], M);
|
•
|
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));
|
| (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]);
|
| (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.
|
•
|
For type "D" space-times there are always two principal null directions.
|
>
|
PND := PrincipalNullDirections(NT, "D");
|
| (11) |
| (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);
|
•
|
We define a metric depending upon 2 parameters .
|
>
|
g := evalDG(1/y^(2)*(dy &t dy - du &s dv ) + y^(2*p)*dz &t dz + y^(2*q) *dv &t dv);
|
| (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]);
|
| (15) |
•
|
We find that this metric is of Petrov type "I" for generic values of the parameters . There are exceptional values leading to space-times of Petrov type "N", "D", "O".
|
>
|
PetrovType(NT, parameters = [p, 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]);
|
| (17) |
|
|
Case Splitting with KillingVectors
|
|
•
|
We first define a simple class of metrics in two dimensions, depending upon a parameter .
|
>
|
g := evalDG(y^k*( dx &t dx + dy &t dy));
|
•
|
When , 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 .
|
•
|
When , this becomes the well-known metric for the Poincare half-plane and again there are 3 Killing vectors.
|
•
|
For other values of , there is an obvious Killing vector .
|
•
|
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});
|
| (20) |
|
|
Minimal Subalgebras of Matrices
|
|
•
|
The command MinimalSubalgebras has been extended to work with matrices. Given a list of matrices , this command with calculate the smallest list of matrices which contains 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]])];
|
| (21) |
>
|
B := MinimalSubalgebra(A);
|
| (22) |
|
|
Matrix Groups
|
|
•
|
Given a matrix algebra, as defined by a list of matrices 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 . 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]]):
|
| (23) |
>
|
B, Id := MatrixGroup(A, [u, v, x, y]);
|
| (24) |
•
|
The 4-parameter family of matrices 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([a, b, c, d, e], G);
|
>
|
T := Transformation(M, M, [x = a*x + b*y +c, y = d*y + e]);
|
| (27) |
| (28) |
>
|
LG:-LeftMultiplication([alpha, beta, gamma, delta, epsilon]);
|
| (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);
|
| (30) |
•
|
We find the most general rank 2, contravariant, symmetric tensor on the Lie algebra involving the vectors and invariant with respect to .
|
>
|
Q := GenerateSymmetricTensors([e2, e3, e4],2);
|
| (31) |
>
|
InvariantGeometricObjectFields([e1], Q, output = "list");
|
•
|
We find the most general rank 2, covariant symmetric tensor on the Lie algebra involving the dual vectors (or 1-forms) and invariant with respect to .
|
>
|
Q := GenerateSymmetricTensors([theta2, theta3, theta4], 2);
|
| (33) |
>
|
InvariantGeometricObjectFields([e1], Q, output = "list");
|
| (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);
|
>
|
Retrieve("Stephani", 1, [12, 14, 1], manifoldname = M, output = ["Fields"]);
|
| (36) |
|
|
|
|
|