An Overview of General Relativity computations with DifferentialGeometry
Description
1. Getting Started
2. Algebraic Manipulations of Tensors
3. Derivatives
4. Useful Utilities
5. Curvature Tensors
6. Working with Orthonormal Tetrads
7. Working with Null Tetrads and the Newman-Penrose Formalism
8. Two Component Spinor Formalism
9. Congruences
10. Electro-Vac Spacetimes
11. Exact Solution Database
12. Other Features
The GRTensor package, developed by K. Lake, P. Musgrave and D. Polleny, has long provided the general relativity community with an excellent collection of command for symbolic computations in general relativity. This functionality is also now available within the DifferentialGeometry package and its subpackage Tensor, as well as within the Physics package.
This worksheet provides a quick introduction to General Relativity computations using DifferentialGeometry.
In this section we give a quick illustration of the use of the DifferentialGeometry software to perform a standard calculation in General Relativity. We shall solve the Einstein vacuum equations for spherically symmetric metrics in 4-dimensions. We check that the solution is of Petrov type D and we show that there are 4 Killing vectors. First load the DifferentialGeometry package, the Tensor subpackage and the Tools subpackage.
with(DifferentialGeometry): with(Tensor): with(Tools):
All calculations in DifferentialGeometry begin by using the DGsetup command to initialize the computational environment. For our illustration we shall use standard spherical coordinates We use the name M1 to designate the computational environment (in this case a 4-dimensional manifold) which we are creating.
DGsetup([t, r, theta, phi], M1, verbose);
The following coordinates have been protected:
t,r,θ,φ
The following vector fields have been defined and protected:
D_t,D_r,D_θ,D_φ
The following differential 1-forms have been defined and protected:
dt,dr,dθ,dφ
frame name: M1
The coordinate vectors and the 1-forms are now defined and these can be used to construct general vector fields, differential forms and tensors. Use +/- for addition and subtraction, * for scalar multiplication, &t for tensor product and &w for wedge product. The command evalDG is used to insure that these operations are properly performed in DifferentialGeometry.
Here is the usual form for the static (time-independent), rotational invariant metric that is used as the starting ansatz for solving the Einstein equations. The two functions Ar and Br will be determined by the Einstein equations
g := evalDG( A(r) *dt &t dt + B(r)* dr &t dr + r^2*(dtheta &t dtheta + sin(theta)^2* dphi &t dphi));
g≔A⁡r⁢dt⁢dt+B⁡r⁢dr⁢dr+r2⁢dθ⁢dθ+r2⁢sin⁡θ2⁢dφ⁢dφ
To solve the Einstein equations for this metric, we first calculate the Einstein tensor.
Ein := EinsteinTensor(g);
Ein≔−r⁢ⅆⅆrB⁡r+B⁡r2−B⁡r⁢D_tA⁡r⁢r2⁢B⁡r2⁢D_t−A⁡r⁢B⁡r−ⅆⅆrA⁡r⁢r−A⁡r⁢D_rA⁡r⁢B⁡r2⁢r2⁢D_r−ⅆⅆrB⁡r⁢A⁡r⁢ⅆⅆrA⁡r⁢r−2⁢B⁡r⁢ⅆ2ⅆr2A⁡r⁢A⁡r⁢r+B⁡r⁢ⅆⅆrA⁡r2⁢r+2⁢ⅆⅆrB⁡r⁢A⁡r2−2⁢ⅆⅆrA⁡r⁢B⁡r⁢A⁡r⁢D_θ4⁢r3⁢B⁡r2⁢A⁡r2⁢D_θ−ⅆⅆrB⁡r⁢A⁡r⁢ⅆⅆrA⁡r⁢r−2⁢B⁡r⁢ⅆ2ⅆr2A⁡r⁢A⁡r⁢r+B⁡r⁢ⅆⅆrA⁡r2⁢r+2⁢ⅆⅆrB⁡r⁢A⁡r2−2⁢ⅆⅆrA⁡r⁢B⁡r⁢A⁡r⁢D_φ4⁢r3⁢B⁡r2⁢A⁡r2⁢sin⁡θ2⁢D_φ
The command DGinfo is a utility program that can be used to obtain information about the computational environment and information about various DifferentialGeometry objects. Here we use DGinfoto extract all the coefficients of the Einstein tensor.
EinEq := DGinfo(Ein, "CoefficientSet");
EinEq≔−ⅆⅆrB⁡r⁢A⁡r⁢ⅆⅆrA⁡r⁢r−2⁢B⁡r⁢ⅆ2ⅆr2A⁡r⁢A⁡r⁢r+B⁡r⁢ⅆⅆrA⁡r2⁢r+2⁢ⅆⅆrB⁡r⁢A⁡r2−2⁢ⅆⅆrA⁡r⁢B⁡r⁢A⁡r4⁢r3⁢B⁡r2⁢A⁡r2,−r⁢ⅆⅆrB⁡r+B⁡r2−B⁡rA⁡r⁢r2⁢B⁡r2,−A⁡r⁢B⁡r−ⅆⅆrA⁡r⁢r−A⁡rA⁡r⁢B⁡r2⁢r2,−ⅆⅆrB⁡r⁢A⁡r⁢ⅆⅆrA⁡r⁢r−2⁢B⁡r⁢ⅆ2ⅆr2A⁡r⁢A⁡r⁢r+B⁡r⁢ⅆⅆrA⁡r2⁢r+2⁢ⅆⅆrB⁡r⁢A⁡r2−2⁢ⅆⅆrA⁡r⁢B⁡r⁢A⁡r4⁢r3⁢B⁡r2⁢A⁡r2⁢sin⁡θ2
Now we use the Maple command pdsolve to integrate these differential equations:
Soln := pdsolve(EinEq);
Soln≔A⁡r=r+c__1⁢c__2r,B⁡r=rr+c__1
The constant _C1 is essentially the mass of the point source of the gravitational field. The constant _C2 is easily normalized to -1 by a re-scaling of time.
gS := subs({_C1 = - 2*m, _C2= -1},subs(Soln, g));
gS≔−r−2⁢m⁢dtr⁢dt+r⁢drr−2⁢m⁢dr+r2⁢dθ⁢dθ+r2⁢sin⁡θ2⁢dφ⁢dφ
This is the Schwarzschild metric in standard coordinates. The Einstein tensor vanishes as required.
EinsteinTensor(gS);
0⁢D_t⁢D_t
The metric admits 4 Killing vectors.
K := KillingVectors(gS);
K≔−D_t,sin⁡φ⁢D_θ+cos⁡φ⁢cot⁡θ⁢D_φ,cos⁡φ⁢D_θ−sin⁡φ⁢cot⁡θ⁢D_φ,D_φ
subs({sqrt(1-cos(2*theta)) = sqrt(2)*sin(theta)}, K);
−D_t,sin⁡φ⁢D_θ+cos⁡φ⁢cot⁡θ⁢D_φ,cos⁡φ⁢D_θ−sin⁡φ⁢cot⁡θ⁢D_φ,D_φ
The Petrov type of this metric is "D".
PetrovType(gS);
D
It is often convenient to store the entries of a metric in a symmetric matrix.
convert(convert(gS, DGArray), Matrix);
−r−2⁢mr0000rr−2⁢m0000r20000r2⁢sin⁡θ2
We use a simple metric defined on a 3-dimensional space to illustrate some basis algebraic manipulations with tensors.
First define a coordinate chart with coordinates
DGsetup([x, y, z], M2);
frame name: M2
Define a metric g.
g2 := evalDG(z*(dx&t dy + dy &t dx) + x^2*dz &t dz);
g2≔z⁢dx⁢dy+z⁢dy⁢dx+x2⁢dz⁢dz
Calculate the inverse metric
h := InverseMetric(g2);
h≔D_xz⁢D_y+D_yz⁢D_x+D_zx2⁢D_z
Define a rank 3 tensor.
T := evalDG(dx &t D_y &t dz);
T≔dx⁢D_y⁢dz
Lower the second index of T.
RaiseLowerIndices(g2, T, [2]);
z⁢dx⁢dx⁢dz
Raise the 1st and 3rd indices of T using the inverse metric h.
RaiseLowerIndices(h, T, [1,3]);
D_yz⁢x2⁢D_y⁢D_z
Rearrange the 1st and 2nd indices.
RearrangeIndices(T, [[1,2]]);
D_y⁢dx⁢dz
Symmetrize over the 1st and 3rd indices
SymmetrizeIndices(T, [1, 3], "Symmetric");
dx2⁢D_y⁢dz+dz2⁢D_y⁢dx
One can compute the exterior derivative of a differential form, the Lie derivative of any tensor field with respect to a vector field or the covariant derivative of any tensor field with respect to a connection
DGsetup([x, y, z], N);
frame name: N
Define a 1-form and calculate the exterior derivative.
omega := evalDG(sin(x) *dy + x^2*dz);
ω≔sin⁡x⁢dy+x2⁢dz
ExteriorDerivative(omega);
cos⁡x⁢dx⁢⋀⁢dy+2⁢x⁢dx⁢⋀⁢dz
Define a vector field X and a tensor T and calculate the Lie derivative.
X := evalDG(y*D_x + x*D_z);
X≔y⁢D_x+x⁢D_z
T := evalDG(x^2*D_y &t dz);
T≔x2⁢D_y⁢dz
LieDerivative(X, T);
−x2⁢D_x⁢dz+x2⁢D_y⁢dx+2⁢y⁢x⁢D_y⁢dz
Define a connection and calculate the covariant derivative of T.
C := Connection(a*D_z &t dx &t dy);
C≔a⁢D_z⁢dx⁢dy
CovariantDerivative(T, C);
−a⁢x2⁢D_y⁢dx⁢dy+2⁢x⁢D_y⁢dz⁢dx
The DifferentialGeometry package has many useful utilities for working with differential forms and tensors. For example, we can easily construct a general metric as follows. (GenerateSymmetricTensors, DGzip)
S := GenerateSymmetricTensors([dx, dy , dz], 2);
S≔dx⁢dx,dx2⁢dy+dy2⁢dx,dx2⁢dz+dz2⁢dx,dy⁢dy,dy2⁢dz+dz2⁢dy,dz⁢dz
g := DGzip([a1,a2,a3,a4,a5,a6](x, y, z), S, "plus");
g≔a1⁡x,y,z⁢dx⁢dx+a2⁡x,y,z⁢dx2⁢dy+a3⁡x,y,z⁢dx2⁢dz+a2⁡x,y,z⁢dy2⁢dx+a4⁡x,y,z⁢dy⁢dy+a5⁡x,y,z⁢dy2⁢dz+a3⁡x,y,z⁢dz2⁢dx+a5⁡x,y,z⁢dz2⁢dy+a6⁡x,y,z⁢dz⁢dz
As another example, we can get the components of any tensor with respect to any basis with the command GetComponents.
B := evalDG([dx , dx -dy, dx +2*dy -dz]);
B≔dx,dx−dy,dx+2⁢dy−dz
alpha := evalDG(dx - 3*dy + 5*dz);
α≔dx−3⁢dy+5⁢dz
GetComponents(alpha, B);
13,−7,−5
The Riemann curvature tensor, the Ricci tensor, the Ricci scalar and the Weyl tensor of a metric are easily computed. Here we use the Godel metric.
DGsetup([x, y, z, t], M5);
frame name: M5
To define the metric, we first define a 1-form and then define the metric in terms of the 1-form.
omega := evalDG(dt + exp(x)*dz);
ω≔ⅇx⁢dz+dt
g5 := evalDG(dx &t dx + dy &t dy +1/2*exp(2*x)*dz &t dz - omega &t omega);
g5≔dx⁢dx+dy⁢dy−ⅇ2⁢x⁢dz2⁢dz−ⅇx⁢dz⁢dt−ⅇx⁢dt⁢dz−dt⁢dt
Here is the curvature tensor (as a type (1, 3)) tensor.
CurvatureTensor(g5);
3⁢ⅇ2⁢x⁢D_x4⁢dz⁢dx⁢dz+ⅇx⁢D_x2⁢dz⁢dx⁢dt−3⁢ⅇ2⁢x⁢D_x4⁢dz⁢dz⁢dx−ⅇx⁢D_x2⁢dz⁢dt⁢dx+ⅇx⁢D_x2⁢dt⁢dx⁢dz+D_x2⁢dt⁢dx⁢dt−ⅇx⁢D_x2⁢dt⁢dz⁢dx−D_x2⁢dt⁢dt⁢dx−D_z2⁢dx⁢dx⁢dz+D_z2⁢dx⁢dz⁢dx+ⅇx⁢D_z2⁢dz⁢dz⁢dt−ⅇx⁢D_z2⁢dz⁢dt⁢dz+D_z2⁢dt⁢dz⁢dt−D_z2⁢dt⁢dt⁢dz+ⅇx⁢D_t⁢dx⁢dx⁢dz+D_t2⁢dx⁢dx⁢dt−ⅇx⁢D_t⁢dx⁢dz⁢dx−D_t2⁢dx⁢dt⁢dx−ⅇ2⁢x⁢D_t4⁢dz⁢dz⁢dt+ⅇ2⁢x⁢D_t4⁢dz⁢dt⁢dz−ⅇx⁢D_t2⁢dt⁢dz⁢dt+ⅇx⁢D_t2⁢dt⁢dt⁢dz
Here is the Ricci tensor.
RicciTensor(g5);
ⅇ2⁢x⁢dz⁢dz+ⅇx⁢dz⁢dt+ⅇx⁢dt⁢dz+dt⁢dt
Here is the Ricci scalar.
RicciScalar(g5);
−1
Many calculations in General Relativity can be dramatically simplified by defining an orthonormal tetrad and by expressing the metric and all other tensors in terms of this orthonormal tetrad. This is particularly true when a co-frame can be chosen with simple structure equations.
A simple illustration of this is provided by the Godel metric from the previous example.
DGsetup([x, y, z, t], M6);
frame name: M6
g6 := evalDG(dx &t dx + dy &t dy +1/2*exp(2*x)*dz &t dz - omega &t omega);
g6≔dx⁢dx+dy⁢dy−ⅇ2⁢x⁢dz2⁢dz−ⅇx⁢dz⁢dt−ⅇx⁢dt⁢dz−dt⁢dt
Omega := evalDG([dx, dy, 1/sqrt(2)*exp(x)*dz, omega]);
Ω≔dx,dy,2⁢ⅇx⁢dz2,ⅇx⁢dz+dt
We use TensorInnerProduct to check that the forms in the list define an orthonormal tetrad.
TensorInnerProduct(g6, Omega, Omega);
100001000010000−1
The command FrameData calculates the structure equations for this frame and stores the results in a format that can be used by DGsetup.
FD := FrameData(Omega, O6);
FD≔d⁢Θ1=0,d⁢Θ2=0,d⁢Θ3=Θ1⁢⋀⁢Θ3,d⁢Θ4=2⁢Θ1⁢⋀⁢Θ3
What is nice about this co-frame is that the structure functions are all constant -- even though there was an exponential function in the metric. We run DGsetup again to create a new computational environment which used this co-frame and these structure equations.
DGsetup(FD, [E], [theta]);
frame name: O6
newg6 := evalDG(theta1 &t theta1 + theta2 &t theta2 + theta3 &t theta3 - theta4 &t theta4);
newg6≔θ1⁢θ1+θ2⁢θ2+θ3⁢θ3−θ4⁢θ4
The curvature tensor and the Ricci tensor take simple forms in terms of this frame.
CurvatureTensor(newg6);
E12⁢θ3⁢θ1⁢θ3−E12⁢θ3⁢θ3⁢θ1+E12⁢θ4⁢θ1⁢θ4−E12⁢θ4⁢θ4⁢θ1−E32⁢θ1⁢θ1⁢θ3+E32⁢θ1⁢θ3⁢θ1+E32⁢θ4⁢θ3⁢θ4−E32⁢θ4⁢θ4⁢θ3+E42⁢θ1⁢θ1⁢θ4−E42⁢θ1⁢θ4⁢θ1+E42⁢θ3⁢θ3⁢θ4−E42⁢θ3⁢θ4⁢θ3
RicciTensor(newg6);
θ4⁢θ4
The DifferentialGeometry package supported computations in all the different formalisms for general relativity -- coordinate calculations, orthonormal tetrads, null tetrads and the Newman-Penrose formalism, and the two-component spinor formalism. The tools are readily available for moving from one formalism to another.
In this example we calculate the Newman-Penrose curvature scalars for a metric.
DGsetup([r, u, x, y], M7);
frame name: M7
g7 := evalDG(dr &t du + du &t dr -((2*(3*x*r+m))*du &t du)/r-(1/4)*(r^2*dx &t dx)/x^3-(1/4)*(r^2*dy &t dy)/x^3);
g7≔dr⁢du+du⁢dr−2⁢3⁢x⁢r+m⁢dur⁢du−r2⁢dx4⁢x3⁢dx−r2⁢dy4⁢x3⁢dy
The command DGGramSchmidt and NullTetrad provide useful tools for constructing null tetrads. Here is the one that we shall use for this example
NT := evalDG([D_r, (3*x*r+m)*D_r/r+D_u, I*sqrt(2)*x^(3/2)*D_x/r+sqrt(2)*x^(3/2)*D_y/r, -I*sqrt(2)*x^(3/2)*D_x/r+sqrt(2)*x^(3/2)*D_y/r]);
NT≔D_r,3⁢x⁢r+m⁢D_rr+D_u,I⁢2⁢x32⁢D_xr+2⁢x32⁢D_yr,−I⁢2⁢x32⁢D_xr+2⁢x32⁢D_yr
Here are the Newman-Penrose curvature scalars for this null tetrad.
NP := NPCurvatureScalars(NT, output = ["WeylScalars"]);
NP≔table⁡Psi3=−3⁢I⁢2⁢x32r2,Psi1=0,Psi0=0,Psi4=18⁢x2r2,Psi2=−mr3
As a quick illustration of the 2-component spinor formalism, we calculate the Weyl spinor for the metric from the previous paragraph. To work with spinors we use DGsetup to specify both the coordinates for the space-time and also the coordinates to be used for the spinors and their complex conjugates.
DGsetup([r, u, x, y], [z1, z2, w1, w2], M8);
frame name: M8
Here is metric as before.
g8 := evalDG(dr &t du + du &t dr -((2*(3*x*r+m))*du &t du)/r-(1/4)*(r^2*dx &t dx)/x^3-(1/4)*(r^2*dy &t dy)/x^3);
g8≔dr⁢du+du⁢dr−2⁢3⁢r⁢x+m⁢dur⁢du−r2⁢dx4⁢x3⁢dx−r2⁢dy4⁢x3⁢dy
Here is the null tetrad as before.
NT≔D_r,3⁢r⁢x+m⁢D_rr+D_u,I⁢2⁢x32⁢D_xr+2⁢x32⁢D_yr,−I⁢2⁢x32⁢D_xr+2⁢x32⁢D_yr
We use the null tetrad to construction an orthonormal tetrad.
OT := OrthonormalTetrad(NT);
OT≔2⁢3⁢r⁢x+m+r⁢D_r2⁢r+2⁢D_u2,2⁢x32⁢D_yr,2⁢x32⁢D_xr,−2⁢3⁢r⁢x+m−r⁢D_r2⁢r−2⁢D_u2
We use the orthonormal tetrad to define the solder form as a spin-tensor σa AX'.
sigma := SolderForm(OT);
σ≔dr⁢D_z1⁢D_w1−3⁢r⁢x+m⁢dur⁢D_z1⁢D_w1+du⁢D_z2⁢D_w2−I4⁢r⁢2⁢dxx32⁢D_z1⁢D_w2+I4⁢r⁢2⁢dxx32⁢D_z2⁢D_w1+r⁢2⁢dy4⁢x32⁢D_z1⁢D_w2+r⁢2⁢dy4⁢x32⁢D_z2⁢D_w1
Here is the null vector as a 2-component spinor.
convert(D_r, DGspinor, sigma, [1]);
D_z1⁢D_w1
We use SpinorInnerProduct to check that the contracted product re-produces the metric.
SpinorInnerProduct(sigma, sigma);
dr⁢du+du⁢dr−2⁢3⁢r⁢x+m⁢dur⁢du−r2⁢dx4⁢x3⁢dx−r2⁢dy4⁢x3⁢dy
Here is the Weyl spinor.
WeylSpinor(sigma);
m⁢dz1r3⁢dz1⁢dz2⁢dz2+m⁢dz1r3⁢dz2⁢dz1⁢dz2+m⁢dz1r3⁢dz2⁢dz2⁢dz1+3⁢I⁢2⁢x32⁢dz1r2⁢dz2⁢dz2⁢dz2+m⁢dz2r3⁢dz1⁢dz1⁢dz2+m⁢dz2r3⁢dz1⁢dz2⁢dz1+3⁢I⁢2⁢x32⁢dz2r2⁢dz1⁢dz2⁢dz2+m⁢dz2r3⁢dz2⁢dz1⁢dz1+3⁢I⁢2⁢x32⁢dz2r2⁢dz2⁢dz1⁢dz2+3⁢I⁢2⁢x32⁢dz2r2⁢dz2⁢dz2⁢dz1−18⁢x2⁢dz2r2⁢dz2⁢dz2⁢dz2
Line congruences (especially null congruences) play an important role in the geometric analysis of space-times. We continue with the metric from the previous example. We show that the congruence defined by D_ris defines a shear-free principal null direction.
U := D_r;
U≔D_r
V := evalDG((3*x*r+m)*D_r/r+D_u);
V≔3⁢r⁢x+m⁢D_rr+D_u
W := WeylTensor(g8):
GRQuery(U, g8, W, "PrincipalNullDirection");
true
Here are the properties of the null congruence defined by U.
CongruenceProperties(g8, U, V);
table⁡RotationScalar=0,RotationNormSquared=0,Raychaudhuri=0,RotationTensor=0⁢dr⁢dr,ShearNormSquared=0,Expansion=2r,ShearTensor=0⁢dr⁢dr
A space-time is called an electro-vac space-time if there exists an electromagnetic field which solves the Einstein-Maxwell field equations. The problem of deciding if a space-time is electro-vac can be solved using the command RainichConditions and RainichElectromagneticField. Here is a simple example.
DGsetup([t, x, y, z], M10);
frame name: M10
g10 := evalDG(4/3*t^2* dx &t dx + t*(exp(-2*x)* dy &t dy + exp(2*x)*dz &t dz) - dt &t dt);
g10≔−dt⁢dt+4⁢t2⁢dx3⁢dx+t⁢ⅇ−2⁢x⁢dy⁢dy+t⁢ⅇ2⁢x⁢dz⁢dz
Test to see if the Rainich conditions for a spacetime hold.
RainichConditions(g10);
We conclude the space-time is an electro-vac spacetime. Here is the electro-magnetic field.
F := RainichElectromagneticField(g10);
F≔2⁢cos⁡c__1⁢1+csgn⁡1t2⁢dt6⁢csgn⁡1t2+6⁢⋀⁢dx+sin⁡c__1⁢1+csgn⁡1t2⁢csgn⁡1t2⁢dy2⁢csgn⁡1t2+2⁢⋀⁢dz
F := simplify(F) assuming t > 0;
F≔2⁢cos⁡c__1⁢3⁢dt3⁢⋀⁢dx+sin⁡c__1⁢dy⁢⋀⁢dz
We check that the Einstein equations are satisfied (See EinsteinTensor, EnergyMomentumTensor).
T := EnergyMomentumTensor("Electromagnetic", g10, F); E := EinsteinTensor(g10); E &minus T;
T≔D_t2⁢t2⁢D_t−3⁢D_x8⁢t4⁢D_x+ⅇ2⁢x⁢D_y2⁢t3⁢D_y+ⅇ−2⁢x⁢D_z2⁢t3⁢D_z
E≔D_t2⁢t2⁢D_t−3⁢D_x8⁢t4⁢D_x+ⅇ2⁢x⁢D_y2⁢t3⁢D_y+ⅇ−2⁢x⁢D_z2⁢t3⁢D_z
We check that the Maxwell equations (see MatterFieldEquations) are satisfied.
MatterFieldEquations("Electromagnetic", g10, F);
0⁢D_t,0⁢dt⁢⋀⁢dx⁢⋀⁢dy
An database of exact solutions of the Einstein equations can be accessed using either the Browse and or the MetricSearch commands from the DifferentialGeometry Library subpackage.
Transformation between space-times can be constructed. See Transformation, Pullback, Pushforward
The Segre classification of space-time can be calculated.
The KillingVector and PetrovType commands support case-splitting for metrics which depend upon arbitrary parameters or functions.
Killing tensors, Killing-Yano tensors, Killing spinors and recurrent tensors can all be calculated.
The LieAlgebras package provides all the tools needed for a complete algebraic analysis of the Killing vectors of a space-time.
The isotropy subalgebra and isotropy type of a Lie algebra of Killing vectors can be determined. These are useful properties for classifying Killing vectors.
Invariant metrics for any Lie algebra of vector fields can be easily computed using the command InvariantGeometricObjectFields in the GroupActions package.
Residual diffeomorphism groups for reductions of space-times can be calculated with the command InfinitisimalPseudoGroupNormalizer
Future releases of DifferentialGeometry will include commands for working with the Einstein-Yang-Mills equations and for abstractly solving the Einstein equations on homogeneous spaces and low cohomogeneity manifolds.
See Also
Physics
Physics[Christoffel]
Physics[D_]
Physics[Einstein]
Physics[Ricci]
Physics[Riemann]
Physics[Weyl]
Download Help Document