DifferentialGeometry Lessons
Lesson 4: The Lie bracket and the Lie derivative
Overview
LieBracket
LieDerivative
Application 1 -- Integrable distributions
Application 2 -- Integrable distributions
DGmap
Application 3 -- Killing Vector Fields
Exercises
In this lesson, you will learn to do the following:
Calculate the Lie bracket of a pair of vector fields.
Calculate the Lie derivative of a function, a vector field, a differential form, and a tensor.
Check that a collection of vector fields defines an integrable distribution.
Find the integral manifolds for an integrable distribution.
Use the utility DGmap, which has the same function as the Maple map and map2 commands.
Find the Killing equations for a metric tensor.
Write programs which will test various identities satisfied by the Lie bracket and the Lie derivative.
The Lie bracket of two vector fields is computed using the LieBracket command.
with(DifferentialGeometry):
DGsetup([x, y, z], "M"):
Define 2 vector fields X and Y and compute their Lie bracket.
X := evalDG(x*D_x + y*D_y);
X ≔ x⁢D_x+y⁢D_y
Y := evalDG(x*y*D_z);
Y ≔ x⁢y⁢D_z
LieBracket(X, Y);
2⁢x⁢y⁢D_z
The DifferentialGeometry command LieDerivative may be applied to Maple expressions, vectors, forms, tensors, and connections.
Define a vector field X and calculate the Lie derivative of some DifferentialGeometry objects.
[1] Functions
f := x^2 - y^2;
f ≔ x2−y2
LieDerivative(X, f);
2⁢x2−2⁢y2
[2] Vector Fields
LieDerivative(X, Y);
In this case, the LieDerivative agrees with the Lie bracket.
[3] Differential Forms
alpha := evalDG(z*dy - y*dz);
α ≔ z⁢dy−y⁢dz
LieDerivative(X, alpha);
z⁢dy−y⁢dz
[4] Tensors
T := evalDG(dx &t dx &t dx);
T ≔ dx⁢dx⁢dx
LieDerivative(X, T);
3⁢dx⁢dx⁢dx
A collection of vector fields {X1, X2, ..., Xp} define an integrable distribution if, for all i, j = 1 .. p, the Lie brackets [Xi, Xj] are linear combination of the vectors {X1, X2, ..., Xp}.
Here we check that the given vectors define an integrable distribution. We can do this using either the GetComponents or the Annihilator commands discussed in Lesson 3. In the exercises, you will be asked to write a program to determine if a list of vectors is integrable.
with(DifferentialGeometry): DGsetup([x, y, z, u, v], E5);
frame name: E5
X1 := evalDG(z*u*D_x - 2*x*z*D_z + 2*v*x*D_v);
X1 ≔ z⁢u⁢D_x−2⁢x⁢z⁢D_z+2⁢v⁢x⁢D_v
X2 := evalDG(z*D_y - 2*y*D_v);
X2 ≔ z⁢D_y−2⁢y⁢D_v
X3 := evalDG(-z*D_z + u*D_u + v*D_v);
X3 ≔ −z⁢D_z+u⁢D_u+v⁢D_v
Show that the vectors fields {X1, X2, X3} define a 3 dimensional integrable distribution. First we use the DGbasis command to check that the 3 vectors X1, X2, X3 are independent.
Y := DGbasis([X1, X2, X3]);
Y ≔ z⁢u⁢D_x−2⁢x⁢z⁢D_z+2⁢v⁢x⁢D_v,z⁢D_y−2⁢y⁢D_v,−z⁢D_z+u⁢D_u+v⁢D_v
nops(Y);
3
Next, we compute all possible brackets and check that they are in the span of the vectors {X1, X2, X3}.
X12 := LieBracket(X1, X2):
X13 := LieBracket(X1, X3):
X23 := LieBracket(X2, X3):
GetComponents(X12, [X1, X2, X3]);
0,−2⁢x,0
GetComponents(X13, [X1, X2, X3]);
0,0,0
GetComponents(X23, [X1, X2, X3]);
0,1,0
We remark that that these calculations can be done with just a single call to GetComponents.
GetComponents([X12, X13, X23], [X1, X2, X3]);
0,−2⁢x,0,0,0,0,0,1,0
Since each bracket is a linear combination of the vectors {X1, X2, X3}, these calculations prove that the {X1, X2, X3} is an integrable distribution. Here is an alternative method. First, calculate the annihilator C for the vectors {X1, X2, X3}. Then a vector Z is in the span of the vectors {X1, X2, X3} if and only if the interior product of Z with each 1-form in C is zero.
C := Annihilator([X1, X2, X3]);
C ≔ 2⁢x⁢dxz+u⁢dzz+du,2⁢y⁢dyz+v⁢dzz+dv
f := (i,j) -> Hook([X12, X13, X23][i], C[j]);
f ≔ i,j→DifferentialGeometry:-Hook⁡X12,X13,X23i,Cj
Matrix(3, 2, f);
This is a continuation of the previous example. We use the Maple command pdsolve to find the invariant functions for the distribution defined by the vectors {X1, X2, X3}.
f := 'f':
Eq := map(LieDerivative, [X1, X2, X3], f(x, y, z, u, v));
Eq ≔ z⁢u⁢fx−2⁢x⁢z⁢fz+2⁢v⁢x⁢fv,z⁢fy−2⁢y⁢fv,−z⁢fz+u⁢fu+v⁢fv
A very useful command for improving the output of these computations is the PDEtools command declare.
PDEtools[declare](f(x, y, z, u, v));
f⁡x,y,z,u,v⁢will now be displayed as⁢f
Eq;
z⁢u⁢fx−2⁢x⁢z⁢fz+2⁢v⁢x⁢fv,z⁢fy−2⁢y⁢fv,−z⁢fz+u⁢fu+v⁢fv
pdsolve(Eq, f(x, y, z, u, v));
f=_F1⁡z⁢u+x2,v⁢z+y2
We conclude that a pair of fundamental solutions are.
f1 := x^2 + z*u: f2 := y^2 + z*v:
Check these results using the LieDerivative command.
check := [seq(seq(LieDerivative(X, f), X=[X1, X2, X3]), f=[f1, f2])];
check ≔ 0,0,0,0,0,0
Check these results using the pdetest command.
pdetest(f(x, y, z, u, v) = f1, Eq);
pdetest(f(x, y, z, u, v) = f2, Eq);
Thus the integral manifolds for the 3 dimensional integrable distribution {X1, X2, X3} are the 3 dimensional level surfaces:
x^2 + z*u = c1 and y^2 + z*v = c2.
The DGmap command allows one to apply Maple commands to the coefficients of a DifferentialGeometry vector, form, or tensor. We shall use this utility in the next application. To understand the syntax for this command, it is helpful to first read the help pages for the Maple map and map2 commands. Here are a few simply examples.
DGsetup([x, y], E2);
Define a vector field X, depending upon parameter t.
X := evalDG( x*D_x + t*y*D_y);
X ≔ x⁢D_x+t⁢y⁢D_y
Add 2 to each coefficient of X.
Tools:-DGmap(1, a -> a + 2, X);
x+2⁢D_x+t⁢y+2⁢D_y
Differentiate each coefficient of X with respect to t.
Tools:-DGmap(1, diff, X ,t);
y⁢D_y
Integrate each coefficient of X with respect to t from 0 to 1.
Tools:-DGmap(1, int, X, t = 0 .. 1);
x⁢D_x+y⁢D_y2
In this application, we shall find the infinitesimal symmetries or Killing vectors for the Poincare half-plane. Recall that a vector field X is a Killing vector for a metric tensor g if LieDerivative(X, g) = 0.
frame name: E2
Define the metric g for the Poincare half-plane.
g := (1/y^2) &mult evalDG(dx &t dx + dy &t dy);
g ≔ dx⁢dxy2+dy⁢dyy2
Define a general vector on E2.
X := evalDG(a(x, y)*D_x + b(x, y)*D_y);
X ≔ a⁢D_x+b⁢D_y
PDEtools[declare](a(x, y), b(x, y));
a⁡x,y⁢will now be displayed as⁢a
b⁡x,y⁢will now be displayed as⁢b
Calculate the Lie derivative of the metric g with respect to the vector field X.
LD := LieDerivative(X, g);
LD ≔ 2⁢ax⁢y−b⁢dx⁢dxy3+bx+ay⁢dx⁢dyy2+bx+ay⁢dy⁢dxy2+2⁢by⁢y−b⁢dy⁢dyy3
Extract the coefficients of the Lie derivative LD to obtain the Killing equations for the metric.
KillingEq := Tools:-DGinfo(LD, "CoefficientSet");
KillingEq ≔ 2⁢by⁢y−by3,2⁢ax⁢y−by3,bx+ayy2
Solve the Killing equations with pdsolve.
soln := pdsolve(KillingEq, {a(x, y), b(x, y)});
soln ≔ b=_C1⁢x+_C2⁢y,a=−y2+x2⁢_C12+_C2⁢x+_C3
Substitute the solution obtained by pdsolve back into the vector field X.
newX := eval(X, soln);
newX ≔ −y2+x2⁢_C12+_C2⁢x+_C3⁢D_x+_C1⁢x+_C2⁢y⁢D_y
We use the DGmap utility (see previous section) to generate the 3 Killing vectors associated to the constants _C1, _C2, _C3.
X1 := Tools:-DGmap(1, diff, newX, _C1);
X1 ≔ −y22+x22⁢D_x+y⁢x⁢D_y
X2 := Tools:-DGmap(1, diff, newX, _C2);
X2 ≔ x⁢D_x+y⁢D_y
X3 := Tools:-DGmap(1, diff, newX, _C3);
X3 ≔ D_x
Gamma := [X1, X2, X3]:
We can use the GetComponents command to check that these three vectors define a Lie algebra, that is, that their Lie brackets are constant linear combinations of Gamma.
GetComponents(LieBracket(X1, X2), Gamma, method = "real");
−1,0,0
GetComponents(LieBracket(X1, X3), Gamma, method = "real");
0,−1,0
GetComponents(LieBracket(X2, X3), Gamma, method = "real");
0,0,−1
Later on, we shall see that the command LieAlgebraData, in the LieAlgebras package, will do this automatically. See also the commands InfinitesimalSymmetriesOfGeometricObjectFields and KillingVectors which automate the computations presented in this section.
Exercise 1
For the vector fields, differential forms, and tensors defined below, calculate
[i] the Lie bracket of X and Y.
[ii] the iterated Lie bracket [X, [X, [X, Y]]] and conjecture what the general formula is for the k-th iterated bracket.
[iii] the Lie bracket of X and x^2*Y - x*y*X.
[iv] the Lie derivative of f with respect to X.
[v] the Lie derivative of beta with respect to X.
[vi] the Lie derivative with respect to Y of the interior product of X and alpha.
[vii] the Lie derivative of the tensor product of T with X with respect to X.
DGsetup([x, y, z], M):
X := evalDG(x* D_x - y*z*D_y);
X ≔ x⁢D_x−y⁢z⁢D_y
Y := evalDG(z^2*x*D_z);
Y ≔ z2⁢x⁢D_z
f := sin(x*y) + tan(y*z);
f ≔ sin⁡y⁢x+tan⁡y⁢z
alpha := evalDG(z*dx &w dy - dy &w dz);
α ≔ z⁢dx⁢`^`⁢dy−dy⁢`^`⁢dz
beta := evalDG(dx &w dy &w dz);
β ≔ dx⁢`^`⁢dy⁢`^`⁢dz
T := evalDG(z*dx &t D_y &t dz);
T ≔ z⁢dx⁢D_y⁢dz
Solution
z2⁢x⁢y⁢D_y+z2⁢x⁢D_z
[ii] the iterated Lie bracket [X, [X, [X, Y]]].
X3 := LieBracket(X, LieBracket(X, LieBracket(X, Y)));
X3 ≔ 3⁢z2⁢x⁢y⁢D_y+z2⁢x⁢D_z
X4 := LieBracket(X, X3);
X4 ≔ 4⁢z2⁢x⁢y⁢D_y+z2⁢x⁢D_z
LieBracket(X, X4);
5⁢z2⁢x⁢y⁢D_y+z2⁢x⁢D_z
[iii] the Lie bracket of X and x^2*Y - x*y*X. Note that it is not necessary to "wrap" the arguments of LieBracket in evalDG.
LieBracket(X, x^2*y*Y - x*y*X);
−y⁢x2+y⁢z⁢x2⁢D_x+−y2⁢z2⁢x+y2⁢x3⁢z2+x⁢y2⁢z⁢D_y+3⁢y⁢x3⁢z2−y⁢z3⁢x3⁢D_z
x⁢cos⁡y⁢x⁢y−y⁢z⁢cos⁡y⁢x⁢x+1+tan⁡y⁢z2⁢z
LieDerivative(X, beta);
−z+1⁢dx⁢`^`⁢dy⁢`^`⁢dz
LieDerivative(Y, Hook(X, alpha));
z3⁢y+2⁢y⁢z3⁢x⁢dx+x2⁢z2⁢dy+3⁢x⁢z2⁢y⁢dz
LieDerivative(X, T &t X);
x⁢z+x⁢z2⁢dx⁢D_y⁢dz⁢D_x+−z3⁢y−z2⁢y⁢dx⁢D_y⁢dz⁢D_y
Exercise 2
Write programs which will test the following identities satisfied by the LieBracket [X, Y] and the LieDerivative L_X(T). Each program should return {0} if the identity is satisfied.
[i] [X, Y] = -[Y, X].
[ii] [X, f*Y] = X(f)*Y + f* [X, Y].
[iii] [X, [Y, Z]] + [Z, [X, Y]] + [ Y, [Z, X]] = 0.
[iv] L_X(alpha &w beta) = L_X(alpha) &w beta + alpha &w L_X(beta), where alpha and beta are differential forms.
[v] L_X(T &t S) = L_X(T) &t S + S &t L_X(T), where T and S are tensor fields.
[vi] L_X(Hook(Y, alpha)) = Hook([X, Y], alpha) + Hook(Y, L_X(alpha)).
[vii] L_X L_Y(T) - L_Y L_X(T) = L_[X, Y] T, where T is a vector, differential form, or tensor field.
Here are the programs:
[i] [X, Y] = - [Y, X].
LieBracketSkewSymmetric := proc(X, Y)
local a;
a := LieBracket(X, Y) &plus LieBracket(Y, X);
Tools:-DGinfo(a, "CoefficientSet");
end:
LieBracketDerivation := proc(X, Y, f)
local a, b, b1, b2, c;
a := LieBracket(X, f &mult Y);
b1 := LieDerivative(X, f) &mult Y;
b2 := f &mult LieBracket(X, Y);
b := b1 &plus b2;
c := a &minus b;
Tools:-DGinfo(c, "CoefficientSet");
LieBracketJacobi := proc(X, Y, Z)
local a, a1, a2, a3;
a1 := LieBracket(X, LieBracket(Y, Z));
a2 := LieBracket(Z, LieBracket(X, Y));
a3 := LieBracket(Y, LieBracket(Z, X));
a := a1 &plus a2 &plus a3;
Tools:-DGinfo(a,"CoefficientSet");
We use DGinfo/ObjectType to combine [iv] and [v] into one identity.
[iv] L_X (alpha &w beta) = L_X(alpha) &w beta + alpha &w L_X(beta), where alpha and beta are differential forms.
[v] L_X (T &t S) = L_X(T) &t S + S &t L_X(T), where T and S are tensor fields.
LieDerivativeDerivation := proc(X, T, S)
local DGobject, M, a, b, b1, b2, c;
DGobject := Tools:-DGinfo(T, "ObjectType");
if DGobject = "form" then
M := (x, y) -> x &wedge y;
else
M := (x, y) -> x &tensor y;
fi;
a := LieDerivative(X, M(T, S));
b1 := M(LieDerivative(X, T), S);
b2 := M(T, LieDerivative(X, S));
[vi] L_X(Hook(Y, alpha)) = Hook([X, Y], alpha) + Hook(Y, L_X(alpha))
LieDerivativeHook := proc(X, Y, alpha)
local a, a1, b, b1, b2, b3, b4, c;
a1 := Hook(Y, alpha);
a := LieDerivative(X, a1);
b1 := LieBracket(X, Y);
b2 := Hook(b1, alpha);
b3 := LieDerivative(X, alpha);
b4 := Hook(Y, b3);
b := b2 &plus b4;
LieDerivativeCommutator := proc(X, Y, T)
local a, a1, a2, b, b1, c;
a1 := LieDerivative(X, LieDerivative(Y, T));
a2 := LieDerivative(Y, LieDerivative(X, T));
a := a1 &minus a2;
b := LieDerivative(b1, T);
Here is some test data.
DGsetup([x, y, z], E3);
frame name: E3
X1 := evalDG(y*z*D_x - (x^2 + y^2)*D_y + 3*D_z);
X1 ≔ y⁢z⁢D_x+−x2−y2⁢D_y+3⁢D_z
X2 := evalDG(D_x + x^2*D_y - x*y*D_z);
X2 ≔ D_x+x2⁢D_y−x⁢y⁢D_z
X3 := evalDG(z^2*D_x - x^2*D_y + D_z);
X3 ≔ z2⁢D_x−x2⁢D_y+D_z
f := x*y/z^2;
f ≔ x⁢yz2
alpha1 := evalDG(x^2*dx &w dy - (y/z)*dy &w dz);
α1 ≔ x2⁢dx⁢`^`⁢dy−y⁢dy⁢`^`⁢dzz
alpha2 := evalDG(z*dx + x*dy);
α2 ≔ z⁢dx+x⁢dy
T1 := evalDG(z*dx &t D_y + x^2*dy &t D_z);
T1 ≔ z⁢dx⁢D_y+x2⁢dy⁢D_z
T2 := evalDG(z*D_x &t D_y + x^2*D_z &t D_z);
T2 ≔ z⁢D_x⁢D_y+x2⁢D_z⁢D_z
Here are some tests of the identities.
LieBracketSkewSymmetric(X1, X2);
0
LieBracketDerivation(X1, X2, f);
LieBracketJacobi(X1, X2, X3);
LieDerivativeDerivation(X1, alpha1, alpha2);
LieDerivativeDerivation(X2, T1, T2);
LieDerivativeHook(X1, X2, alpha1);
LieDerivativeCommutator(X1, X2, alpha1);
LieDerivativeCommutator(X2, X3, T2);
Exercise 3
[i] Write a program, DerivedDistribution, whose input is a list of vector fields V and which returns a basis for V1 = V + [V, V], the space of vectors spanned by the elements of V and all possible brackets of elements of V. The distribution of vectors spanned by V1 is called the derived distribution of V.
[ii] Write a program, CheckIntegrable, whose input is a list of vector fields V and which returns true or false according to whether the list of vectors define an integrable distribution or not. If false, then also return the pair of vectors whose bracket is not in V.
[iii] Test your programs on the distributions Va, Vb, Vc, Vd. If the distribution is not integrable, calculate the derived distribution and test it's integrability.
DGsetup([x, y, z, u, v, w], E6):
Va := evalDG([z*u*D_x - 2*x*z*D_z + 2*v*x*D_v, z*D_y - 2*y*D_v, -z*D_z + u*D_u + v*D_v]);
Va ≔ z⁢u⁢D_x−2⁢x⁢z⁢D_z+2⁢v⁢x⁢D_v,z⁢D_y−2⁢y⁢D_v,−z⁢D_z+u⁢D_u+v⁢D_v
Vb := evalDG([D_x, D_y + x*D_z]);
Vb ≔ D_x,D_y+x⁢D_z
Vc := evalDG([x*D_u - y*D_v, y*D_u + x*D_v, -x*D_x - y*D_y + z*D_v, y*D_x - x*D_y - z*D_u]);
Vc ≔ x⁢D_u−y⁢D_v,y⁢D_u+x⁢D_v,−x⁢D_x−y⁢D_y+z⁢D_v,y⁢D_x−x⁢D_y−z⁢D_u
Vd := evalDG([D_u, D_x + z*D_y + u*D_z + exp(y)*D_v + exp(y)*v*D_w]);
Vd ≔ D_u,D_x+z⁢D_y+u⁢D_z+ⅇy⁢D_v+ⅇy⁢v⁢D_w
Part [i]
DerivedDistribution := proc(V)
local V1, V2, p, i, j, k;
p := nops(V);
V1 := Array(1 .. p*(p + 1)/2);
for i to p do
V1[i] := V[i]
od;
k := p;
for j from i + 1 to p do
k := k + 1;
V1[k] := LieBracket(V[i], V[j]);
V2 := convert(V1, list);
DGbasis(V2);
Part [ii]
CheckIntegrable := proc(V1)
local p, i, j, ans, Z;
p := nops(V1):
Z := LieBracket(V1[i], V1[j]);
ans := GetComponents(Z, V1);
if ans = [] then return(false, i, j) fi;
true;
Example 1. The distribution of vectors Va is integrable.
CheckIntegrable(Va);
true
Example 2. The distribution of vectors Vb is not integrable. The derived distribution of Vb is integrable.
CheckIntegrable(Vb);
false,1,2
Vb1 := DerivedDistribution(Vb);
Vb1 ≔ D_x,D_y+x⁢D_z,D_z
CheckIntegrable(Vb1);
Example 3. The distribution of vectors Vc is integrable.
CheckIntegrable(Vc);
Example 4. The distribution of vectors Vd is not integrable. We must calculate several derived distributions before arriving at an integrable one.
CheckIntegrable(Vd);
Vd1 := DerivedDistribution(Vd);
Vd1 ≔ D_u,D_x+z⁢D_y+u⁢D_z+ⅇy⁢D_v+ⅇy⁢v⁢D_w,D_z
CheckIntegrable(Vd1);
false,2,3
Vd2 := DerivedDistribution(Vd1);
Vd2 ≔ D_u,D_x+z⁢D_y+u⁢D_z+ⅇy⁢D_v+ⅇy⁢v⁢D_w,D_z,−D_y
CheckIntegrable(Vd2);
false,2,4
Vd3 := DerivedDistribution(Vd2);
Vd3 ≔ D_u,D_x+z⁢D_y+u⁢D_z+ⅇy⁢D_v+ⅇy⁢v⁢D_w,D_z,−D_y,ⅇy⁢D_v+ⅇy⁢v⁢D_w
CheckIntegrable(Vd3);
Exercise 4
Show that the vector fields Gamma define a real 4 dimensional Lie algebra (with Lie bracket given by LieBracket).
DGsetup([w,x,y,z], E4);
Gamma := evalDG([D_w, D_x, x*D_w + D_y, (1/2*y^2 + 2*w)*D_w + (y + x)*D_x + y*D_y + D_z]);
frame name: E4
Γ ≔ D_w,D_x,x⁢D_w+D_y,y22+2⁢w⁢D_w+y+x⁢D_x+y⁢D_y+D_z
We have to show that the Lie bracket of Gamma[i] and Gamma[j] is a constant linear combination of the vectors in Gamma.
The easiest way to do this is with the following procedure.
F := (i,j) -> GetComponents(LieDerivative(Gamma[i], Gamma[j]), Gamma, method = "real");
F ≔ i,j→DifferentialGeometry:-LinearCombo⁡DifferentialGeometry:-LieDerivative⁡Γi,Γj,Γ,method=real
Answer := Matrix(4, 4, (i, j) -> F(i, j));
Since all the components are constant, we conclude that the vector fields Gamma define a 4 dimensional Lie algebra.
Exercise 5
Find a set of 4 pointwise linearly independent vector fields which commute with the list of vector fields Gamma defined in Exercise 4.
This (Lie algebra) of vector fields is sometimes referred to as the reciprocal Lie algebra to the Lie algebra of vector fields Gamma.
with(DifferentialGeometry): DGsetup([w, x, y, z], E4);
vars:=x, y, z, w;
vars ≔ x,y,z,w
PDETools[declare](a1(vars), a2(vars), a3(vars), a4(vars));
a1⁡x,y,z,w⁢will now be displayed as⁢a1
a2⁡x,y,z,w⁢will now be displayed as⁢a2
a3⁡x,y,z,w⁢will now be displayed as⁢a3
a4⁡x,y,z,w⁢will now be displayed as⁢a4
Z := DGzip([a1(vars), a2(vars), a3(vars), a4(vars)], [D_x, D_y, D_z, D_w], "plus");
Z ≔ a4⁢D_w+a1⁢D_x+a2⁢D_y+a3⁢D_z
EQ := {seq(Tools:-DGinfo(LieBracket(Z, X), "CoefficientSet"), X = Gamma)};
EQ ≔ −12⁢a4w⁢y2−2⁢a4w⁢w−a4x⁢y−a4x⁢x−y⁢a4y−a4z+2⁢a4+a2⁢y,−12⁢a1w⁢y2−2⁢a1w⁢w−a1x⁢y−a1x⁢x−y⁢a1y−a1z+a1+a2,−12⁢a2w⁢y2−2⁢a2w⁢w−a2x⁢y−a2x⁢x−y⁢a2y−a2z+a2,−12⁢a3w⁢y2−2⁢a3w⁢w−a3x⁢y−a3x⁢x−y⁢a3y−a3z,−a4x,−a2x,−a1x,−a3x,−a3w,−a2w,−a1w,−a4w,−x⁢a4w−a4y+a1,−x⁢a3w−a3y,−x⁢a2w−a2y,−x⁢a1w−a1y
EQ := map(op, EQ);
EQ ≔ −12⁢a4w⁢y2−2⁢a4w⁢w−a4x⁢y−a4x⁢x−y⁢a4y−a4z+2⁢a4+a2⁢y,−12⁢a1w⁢y2−2⁢a1w⁢w−a1x⁢y−a1x⁢x−y⁢a1y−a1z+a1+a2,−12⁢a2w⁢y2−2⁢a2w⁢w−a2x⁢y−a2x⁢x−y⁢a2y−a2z+a2,−x⁢a4w−a4y+a1,−x⁢a3w−a3y,−x⁢a2w−a2y,−x⁢a1w−a1y,−a4x,−a3w,−a2w,−a1w,−a4w,−a2x,−a1x,−a3x,−12⁢a3w⁢y2−2⁢a3w⁢w−a3x⁢y−a3x⁢x−y⁢a3y−a3z
soln := pdsolve(EQ, {a1(vars), a2(vars), a3(vars), a4(vars)});
soln ≔ a1=_C2⁢z+_C3⁢ⅇz,a4=y⁢_C2⁢z+_C3⁢ⅇz+_C4⁢ⅇ2⁢z,a3=_C1,a2=_C2⁢ⅇz
newZ := eval(Z, soln);
newZ ≔ y⁢_C2⁢z+_C3⁢ⅇz+_C4⁢ⅇ2⁢z⁢D_w+_C2⁢z+_C3⁢ⅇz⁢D_x+_C2⁢ⅇz⁢D_y+_C1⁢D_z
Answer := [seq(Tools:-DGmap(1, diff, newZ, cat(_C, i)), i = 1 .. 4)];
Answer ≔ D_z,y⁢z⁢ⅇz⁢D_w+z⁢ⅇz⁢D_x+ⅇz⁢D_y,y⁢ⅇz⁢D_w+ⅇz⁢D_x,ⅇ2⁢z⁢D_w
Let's check this result.
Matrix(4, 4, (i, j)->LieBracket(Gamma[i], Answer[j]));
Exercise 6
Find the Killing vectors for the following metrics.
[i] This is the metric for a two-dimensional space of constant curvature.
DGsetup([u, v], M2);
frame name: M2
g1 := evalDG( 1/(1 + k/4*(u^2 + v^2))^2*(du &t du + dv &t dv));
g1 ≔ 16⁢du⁢du4+k⁢u2+k⁢v22+16⁢dv⁢dv4+k⁢u2+k⁢v22
[ii] This is the Godel solution to the Einstein equations.
DGsetup([x ,y, z, t], M4);
frame name: M4
tau := evalDG(dt + exp(x)*dz);
τ ≔ ⅇx⁢dz+dt
g2 := evalDG(dx &t dx + dy &t dy + 1/2*exp(2*x)*dz &t dz - tau &t tau);
g2 ≔ dx⁢dx+dy⁢dy−12⁢ⅇ2⁢x⁢dz⁢dz−ⅇx⁢dz⁢dt−ⅇx⁢dt⁢dz−dt⁢dt
ChangeFrame(M2):
Define a general vector field X.
PDEtools[declare](a(u, v), b(u, v), quiet);
X := evalDG(a(u, v)*D_u + b(u, v)*D_v);
X ≔ a⁢D_u+b⁢D_v
Calculate the Lie derivative of the metric g1 with respect to X.
LD := LieDerivative(X, g1);
LD ≔ 32⁢4⁢au+au⁢k⁢u2+au⁢k⁢v2−2⁢a⁢k⁢u−2⁢b⁢k⁢v⁢du⁢du4+k⁢u2+k⁢v23+16⁢bu+av⁢du⁢dv4+k⁢u2+k⁢v22+16⁢bu+av⁢dv⁢du4+k⁢u2+k⁢v22+32⁢4⁢bv+bv⁢k⁢u2+bv⁢k⁢v2−2⁢a⁢k⁢u−2⁢b⁢k⁢v⁢dv⁢dv4+k⁢u2+k⁢v23
Extract the coefficients of the Lie derivative LD.
KillingEq ≔ 32⁢4⁢bv+bv⁢k⁢u2+bv⁢k⁢v2−2⁢a⁢k⁢u−2⁢b⁢k⁢v4+k⁢u2+k⁢v23,32⁢4⁢au+au⁢k⁢u2+au⁢k⁢v2−2⁢a⁢k⁢u−2⁢b⁢k⁢v4+k⁢u2+k⁢v23,16⁢bu+av4+k⁢u2+k⁢v22
Solve for the unknown coefficients a(u, v), b(u, v).
soln := pdsolve(KillingEq, {a(u, v), b(u, v)});
soln ≔ a=4⁢k2⁢u⁢v⁢_C3+u2−v2⁢_C1−2⁢v⁢_C2⁢k+4⁢_C12⁢k,b=4−k⁢u2+k⁢v2⁢_C3+_C1⁢v+_C2⁢u
newX ≔ 4⁢k2⁢u⁢v⁢_C3+u2−v2⁢_C1−2⁢v⁢_C2⁢k+4⁢_C1⁢D_u2⁢k+4−k⁢u2+k⁢v2⁢_C3+_C1⁢v+_C2⁢u⁢D_v
We use the DGmap utility to generate the 3 Killing vectors associated to the constants _C1, _C2, _C3.
X1 ≔ k22+u22−v22⁢D_u+u⁢v⁢D_v
X2 ≔ −v⁢D_u+u⁢D_v
X3 ≔ −2⁢u⁢v⁢D_u+u2−k2−v2⁢D_v
The Killing vectors for the metric g1 are
Answer1 := [X1, X2, X3];
AnswerA ≔ k22+u22−v22⁢D_u+u⁢v⁢D_v,−v⁢D_u+u⁢D_v,−2⁢u⁢v⁢D_u+u2−k2−v2⁢D_v
ChangeFrame(M4):
vars := x, y ,z, t:
unknowns := [a1, a2, a3, a4](vars):
PDEtools[declare](unknowns, quiet);
X := DGzip(unknowns, [D_x, D_y, D_z, D_t], "plus");
X ≔ a1⁢D_x+a2⁢D_y+a3⁢D_z+a4⁢D_t
LD := LieDerivative(X, g2);
LD ≔ 2⁢a1x⁢dx⁢dx+a2x+a1y⁢dx⁢dy+−a4x⁢ⅇx−12⁢a3x⁢ⅇ2⁢x+a1z⁢dx⁢dz+−a4x−a3x⁢ⅇx+a1t⁢dx⁢dt+a2x+a1y⁢dy⁢dx+2⁢a2y⁢dy⁢dy+−a4y⁢ⅇx+a2z−12⁢a3y⁢ⅇ2⁢x⁢dy⁢dz+−a4y+a2t−a3y⁢ⅇx⁢dy⁢dt+−a4x⁢ⅇx−12⁢a3x⁢ⅇ2⁢x+a1z⁢dz⁢dx+−a4y⁢ⅇx+a2z−12⁢a3y⁢ⅇ2⁢x⁢dz⁢dy+−2⁢a4z⁢ⅇx−a3z⁢ⅇ2⁢x−a1⁢ⅇ2⁢x⁢dz⁢dz+−a4t⁢ⅇx−a4z−12⁢a3t⁢ⅇ2⁢x−a3z⁢ⅇx−a1⁢ⅇx⁢dz⁢dt+−a4x−a3x⁢ⅇx+a1t⁢dt⁢dx+−a4y+a2t−a3y⁢ⅇx⁢dt⁢dy+−a4t⁢ⅇx−a4z−12⁢a3t⁢ⅇ2⁢x−a3z⁢ⅇx−a1⁢ⅇx⁢dt⁢dz+−2⁢a4t−2⁢a3t⁢ⅇx⁢dt⁢dt
KillingEq ≔ −2⁢a4z⁢ⅇx−a3z⁢ⅇ2⁢x−a1⁢ⅇ2⁢x,a2x+a1y,−a4y⁢ⅇx+a2z−12⁢a3y⁢ⅇ2⁢x,−a4x−a3x⁢ⅇx+a1t,−a4x⁢ⅇx−12⁢a3x⁢ⅇ2⁢x+a1z,−a4y+a2t−a3y⁢ⅇx,2⁢a1x,2⁢a2y,−2⁢a4t−2⁢a3t⁢ⅇx,−a4t⁢ⅇx−a4z−12⁢a3t⁢ⅇ2⁢x−a3z⁢ⅇx−a1⁢ⅇx
soln := pdsolve(KillingEq, convert(unknowns, set));
soln ≔ a2=_C1,a1=_C2⁢z+_C3,a3=−_C2⁢z22−_C3⁢z+_C2⁢ⅇ−2⁢x+_C5,a4=−2⁢_C2⁢ⅇ−x+_C4
newX ≔ _C2⁢z+_C3⁢D_x+_C1⁢D_y+−_C2⁢z22−_C3⁢z+_C2⁢ⅇ−2⁢x+_C5⁢D_z+−2⁢_C2⁢ⅇ−x+_C4⁢D_t
We use the DGmap utility to generate the 3 Killing vectors associated to the constants _C1, ..., _C5.
The Killing vectors for the Godel metric are
Answer2 := [seq(Tools:-DGmap(1, diff, newX, _C||i), i = 1 .. 5)];
Answer2 ≔ D_y,z⁢D_x+−z22+ⅇ−2⁢x⁢D_z−2⁢ⅇ−x⁢D_t,D_x−z⁢D_z,D_t,D_z
Exercise 7
In this exercise, we consider the inverse problem to the problem of calculating the Killing vectors for a given metric. Here we are given a Lie algebra of vector fields Gamma and the problem is to find the most general metric which is invariant with respect to Gamma.
The following three examples are taken from Petrov's book Einstein Spaces. Note that the metrics given by Petrov are not the most general invariant metrics for the given Lie algebra of vector fields.
with(DifferentialGeometry): DGsetup([x1, x2, x3, x4], P):
[i] Find the most general metric which is invariant under Lie differentiation with respect to the Lie algebra of vector fields Gamma1 [Einstein Spaces -- equation 32.8].
Gamma1:= evalDG([exp(-x3)*D_x1 - exp(-x3)*x2^2*D_x2 - 2*exp(-x3)*x2*D_x3, D_x3, exp(x3)*D_x2, D_x1]);
Γ1 ≔ ⅇ−x3⁢D_x1−ⅇ−x3⁢x22⁢D_x2−2⁢ⅇ−x3⁢x2⁢D_x3,D_x3,ⅇx3⁢D_x2,D_x1
[ii] Find the most general metric which is invariant under Lie differentiation with respect to the Lie algebra of vector fields Gamma2 [Einstein Spaces -- equation 33.14].
Gamma2 := evalDG([D_x2, D_x3, x3*D_x2 - exp(x1)*D_x3, D_x1 + x2*D_x2 + x3*D_x3, exp(-x1)*D_x1 + (k*x1 - 1/2*exp(-2*x4))*D_x2 + exp(-x1)*D_x4]);
Γ2 ≔ D_x2,D_x3,x3⁢D_x2−ⅇx1⁢D_x3,D_x1+x2⁢D_x2+x3⁢D_x3,ⅇ−x1⁢D_x1+k⁢x1−12⁢ⅇ−2⁢x4⁢D_x2+ⅇ−x1⁢D_x4
[iii] Find the most general metric which is invariant under Lie differentiation with respect to the Lie algebra of vector fields Gamma3 [Einstein Spaces -- equation 33.45].
Gamma3 := [D_x1, D_x2, (x1^2 - x2^2 - x3^2 + x4^2)*D_x1 + 2*x1*x2*D_x2 + 2*x1*x3*D_x3 + 2*x1*x4*D_x4, 2*x1*x2*D_x1 + (x2^2 - x1^2 - x3^2 + x4^2)*D_x2 + 2*x3*x2*D_x3 + 2*x4*x2*D_x4, x2*D_x1 - x1*D_x2, x1*D_x1 + x2*D_x2 + x3*D_x3 + x4*D_x4];
Γ3 ≔ D_x1,D_x2,x12−x22−x32+x42⁢D_x1+2⁢x1⁢x2⁢D_x2+2⁢x1⁢x3⁢D_x3+2⁢x1⁢x4⁢D_x4,2⁢x1⁢x2⁢D_x1+x22−x12−x32+x42⁢D_x2+2⁢x3⁢x2⁢D_x3+2⁢x4⁢x2⁢D_x4,x2⁢D_x1−x1⁢D_x2,x1⁢D_x1+x2⁢D_x2+x3⁢D_x3+x4⁢D_x4
Solutions
We remark that to solve this problem it is helpful to first calculate the Gamma invariant functions and the Gamma invariant 1-forms.
Part [i] First, we calculate the invariant functions -- the invariant tensors are always a module over the ring of invariant functions.
vars := x1, x2, x3, x4;
vars ≔ x1,x2,x3,x4
EQ1 := {seq(LieDerivative(X, f(vars)), X = Gamma1)};
EQ1 ≔ ⅇ−x3⁢fx1−ⅇ−x3⁢x22⁢fx2−2⁢ⅇ−x3⁢x2⁢fx3,fx1,fx3,ⅇx3⁢fx2
pdsolve(EQ1);
f⁡x1,x2,x3,x4=_F1⁡x4
Now we calculate the invariant 1-forms. We already know that because x4 is an invariant dx4 will be an invariant 1-form. Are there other invariant 1-forms?
First we create the general 1-form alpha.
unknowns := seq(a||i(vars), i = 1 .. 4):
alpha := DGzip([unknowns], [dx1, dx2, dx3, dx4], "plus");
α ≔ a1⁢dx1+a2⁢dx2+a3⁢dx3+a4⁢dx4
Lie differentiate alpha with respect to each vector in Gamma1 and get the coefficients of the result.
EQ2 := {seq(Tools:-DGinfo(LieDerivative(X, alpha), "CoefficientSet"), X = Gamma1)}:
InvariantOneFormEquations := map(op, EQ2);
InvariantOneFormEquations ≔ ⅇx3⁢a1x2,ⅇx3⁢a2x2,ⅇx3⁢a4x2,−ⅇ−x3⁢2⁢a3+2⁢x2⁢a2−a2x1+x22⁢a2x2+2⁢x2⁢a2x3,a2x3,a3x1,a3x3,a2x1,a1x1,a1x3,−ⅇ−x3⁢−a1x1+x22⁢a1x2+2⁢x2⁢a1x3,a4x1,a4x3,−ⅇ−x3⁢−a4x1+x22⁢a4x2+2⁢x2⁢a4x3,ⅇx3⁢a2+a3x2,ⅇ−x3⁢2⁢x2⁢a3+x22⁢a2−a1+a3x1−x22⁢a3x2−2⁢x2⁢a3x3
pdsolve(InvariantOneFormEquations);
a1=0,a4=_F1⁡x4,a3=−x2⁢_F2⁡x4,a2=_F2⁡x4
We conclude that a basis for the invariant 1-forms is Omega = [dx2 - x2dx3, dx4]. Let's check this result.
Omega := evalDG([dx2 - x2*dx3, dx4]);
Ω ≔ dx2−x2⁢dx3,dx4
Matrix(2, 4, (i, j) -> LieDerivative(Gamma1[j], Omega[i]));
Now we calculate the invariant symmetric, rank 2 covariant tensors. We already have three such tensors generated from the invariant 1-forms. These are listed in the set S0. Are there more invariant symmetric tensors?
S0 := Tensor:-GenerateSymmetricTensors(Omega, 2);
S0 ≔ dx2⁢dx2−x2⁢dx2⁢dx3−x2⁢dx3⁢dx2+x22⁢dx3⁢dx3,dx2⁢dx42−x2⁢dx3⁢dx42+dx4⁢dx22−x2⁢dx4⁢dx32,dx4⁢dx4
First, we create the general invariant symmetric tensor.
unknowns := seq(b||i(vars), i = 1 .. 10):
S := Tensor:-GenerateSymmetricTensors([dx1, dx2, dx3, dx4], 2):
g := DGzip([unknowns], S, "plus");
g ≔ b1⁢dx1⁢dx1+b2⁢dx1⁢dx22+b3⁢dx1⁢dx32+b4⁢dx1⁢dx42+b2⁢dx2⁢dx12+b5⁢dx2⁢dx2+b6⁢dx2⁢dx32+b7⁢dx2⁢dx42+b3⁢dx3⁢dx12+b6⁢dx3⁢dx22+b8⁢dx3⁢dx3+b9⁢dx3⁢dx42+b4⁢dx4⁢dx12+b7⁢dx4⁢dx22+b9⁢dx4⁢dx32+b10⁢dx4⁢dx4
Lie differentiate g with respect to each vector in Gamma1 and get the coefficients of the result.
EQ3 := {seq(Tools:-DGinfo(LieDerivative(X, g), "CoefficientSet"), X = Gamma1)}:
InvariantSymmetricTensorEq := map(op, EQ3);
InvariantSymmetricTensorEq ≔ ⅇ−x3⁢4⁢x2⁢b8+x22⁢b6−b3+b8x1−x22⁢b8x2−2⁢x2⁢b8x3,12⁢b9x1,12⁢b4x1,12⁢b2x1,b8x1,ⅇx3⁢b5x2,b8x3,12⁢b9x3,12⁢b6x1,−12⁢ⅇ−x3⁢−2⁢x2⁢b3−x22⁢b2+2⁢b1−b3x1+x22⁢b3x2+2⁢x2⁢b3x3,12⁢ⅇx3⁢b2x2,12⁢b6x3,−12⁢ⅇ−x3⁢2⁢b9+2⁢x2⁢b7−b7x1+x22⁢b7x2+2⁢x2⁢b7x3,12⁢b7x1,12⁢b3x3,b10x1,b10x3,ⅇx3⁢b10x2,b5x1,−ⅇ−x3⁢−b1x1+x22⁢b1x2+2⁢x2⁢b1x3,12⁢ⅇx3⁢b2+b3x2,12⁢ⅇx3⁢b7x2,12⁢ⅇ−x3⁢2⁢x2⁢b9+x22⁢b7−b4+b9x1−x22⁢b9x2−2⁢x2⁢b9x3,12⁢b3x1,12⁢b2x3,12⁢b4x3,−ⅇ−x3⁢2⁢b6+4⁢x2⁢b5−b5x1+x22⁢b5x2+2⁢x2⁢b5x3,12⁢b7x3,ⅇx3⁢b6+b8x2,ⅇx3⁢b1x2,−ⅇ−x3⁢−b10x1+x22⁢b10x2+2⁢x2⁢b10x3,−12⁢ⅇ−x3⁢2⁢b3+2⁢x2⁢b2−b2x1+x22⁢b2x2+2⁢x2⁢b2x3,b1x1,b1x3,12⁢ⅇx3⁢b4x2,12⁢ⅇx3⁢b7+b9x2,−12⁢ⅇ−x3⁢−b4x1+x22⁢b4x2+2⁢x2⁢b4x3,b5x3,−12⁢ⅇ−x3⁢4⁢b8−2⁢x22⁢b5+b2−b6x1+x22⁢b6x2+2⁢x2⁢b6x3,12⁢ⅇx3⁢2⁢b5+b6x2
soln := pdsolve(InvariantSymmetricTensorEq);
soln ≔ b8=x22⁢_F3⁡x4−14⁢_F4⁡x4,b7=_F2⁡x4,b1=0,b4=0,b10=_F1⁡x4,b5=_F3⁡x4,b6=−2⁢x2⁢_F3⁡x4,b2=_F4⁡x4,b3=−x2⁢_F4⁡x4,b9=−x2⁢_F2⁡x4
Since the solution depends upon 4 functions of the invariant x4, we conclude that there is one invariant symmetric tensor which is independent of the invariant symmetric tensors generated by the invariant 1-forms.
newg := Tools:-DGsimplify(eval(g, soln));
newg ≔ 12⁢_F4⁡x4⁢dx1⁢dx2−12⁢x2⁢_F4⁡x4⁢dx1⁢dx3+12⁢_F4⁡x4⁢dx2⁢dx1+_F3⁡x4⁢dx2⁢dx2−x2⁢_F3⁡x4⁢dx2⁢dx3+12⁢_F2⁡x4⁢dx2⁢dx4−12⁢x2⁢_F4⁡x4⁢dx3⁢dx1−x2⁢_F3⁡x4⁢dx3⁢dx2+x22⁢_F3⁡x4−14⁢_F4⁡x4⁢dx3⁢dx3−12⁢x2⁢_F2⁡x4⁢dx3⁢dx4+12⁢_F2⁡x4⁢dx4⁢dx2−12⁢x2⁢_F2⁡x4⁢dx4⁢dx3+_F1⁡x4⁢dx4⁢dx4
g1 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 1, _F2(x4) = 0, _F3(x4) = 0, _F4(x4) = 0}));
g1 ≔ dx4⁢dx4
g2 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 0, _F2(x4) = 1, _F3(x4) = 0, _F4(x4) = 0}));
g2 ≔ dx2⁢dx42−x2⁢dx3⁢dx42+dx4⁢dx22−x2⁢dx4⁢dx32
g3 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 0, _F2(x4) = 0, _F3(x4) = 1, _F4(x4) = 0}));
g3 ≔ dx2⁢dx2−x2⁢dx2⁢dx3−x2⁢dx3⁢dx2+x22⁢dx3⁢dx3
g4 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 0, _F2(x4) = 0, _F3(x4) = 1, _F4(x4) = 1}));
g4 ≔ dx1⁢dx22−x2⁢dx1⁢dx32+dx2⁢dx12+dx2⁢dx2−x2⁢dx2⁢dx3−x2⁢dx3⁢dx12−x2⁢dx3⁢dx2+x22−14⁢dx3⁢dx3
We have that g1, g2, g3 are all symmetric products of the invariant 1-forms and g4 is the new invariant tensor (which can be simplified).
Answer1 := [op(S0), g4 &minus S0[1]];
Answer1 ≔ dx2⁢dx2−x2⁢dx2⁢dx3−x2⁢dx3⁢dx2+x22⁢dx3⁢dx3,dx2⁢dx42−x2⁢dx3⁢dx42+dx4⁢dx22−x2⁢dx4⁢dx32,dx4⁢dx4,dx1⁢dx22−x2⁢dx1⁢dx32+dx2⁢dx12−x2⁢dx3⁢dx12−dx3⁢dx34
Check that all the tensors in Answer1 are invariant.
Matrix(4, 4, (i, j) -> LieDerivative(Gamma1[i], Answer1[j]));
Summary: The most general invariant metric is
g := DGzip([a1(x4), a2(x4), a3(x4), a4(x4)], Answer1, "plus");
g ≔ 12⁢a4⁡x4⁢dx1⁢dx2−12⁢a4⁡x4⁢x2⁢dx1⁢dx3+12⁢a4⁡x4⁢dx2⁢dx1+a1⁡x4⁢dx2⁢dx2−a1⁡x4⁢x2⁢dx2⁢dx3+12⁢