DifferentialGeometry Lessons

はじめる前に
新機能一覧
Maple ワークシートの作成
Mapleワークシートを共有
Maple ウィンドウのカスタマイズ
Maple システムのカスタマイズ
コネクティビティ
Mathematics
数学
- テンソル解析
- パッケージ
- ファンクションアドバイザ
- ベキ級数
- ベクトル解析
- 不活性関数
- 代数
- 因数分解と方程式解法
- 基本数学
- 基本的な注意事項
- 変分法
- 変換
- 幾何
- 微分代数方程式
- 微分幾何学
  - Group Actions
  - JetCalculus
  - LieAlgebras
  - Tensor
  - ツール
  - ライブラリ
  - レッスンおよびチュートリアル
    - LieAlgebras
    - チュートリアル
    - 微分幾何学
    - チュートリアルの概要
    - レッスンの概要
  - 概要
  - &wedge
  - Annihilator
  - ApplyTransformation
  - ChangeFrame
  - ComplementaryBasis
  - ComposeTransformations
  - DeRhamHomotopy
  - DGbasis
  - DGDualBasis
  - DGsetup
  - DGzip
  - evalDG
  - ExteriorDerivative
  - Flow
  - FrameData
  - GetComponents
  - Hook
  - InfinitesimalTransformation
  - IntegrateForm
  - IntersectSubspaces
  - InverseTransformation
  - LieBracket
  - LieDerivative
  - Pullback
  - PullbackVector
  - Pushforward
  - RemoveFrame
  - Transformation
  - 参考文献
  - 変換
  - 環境設定
- 微分方程式
- 微積分
- 数
- 数値計算
- 数学関数
- 数論
- 最適化
- 特殊関数
- 統計
- 線形代数
- 群論
- 評価
- 論理
- 過去のパッケージ
- 金融
- 離散数学
- piecewise examples
- グラフ電卓
- 区分関数
物理
プログラミング
グラフィックス
Student パッケージ
Science and Engineering
科学・エンジニアリング
アプリケーションと例題
リファレンス
システム
MapleSim
MapleSim ツールボックス
MapleSim ヘルプ
Tasks
Toolboxes
エラーメッセージガイド
マニュアル
数学アプリ

Lesson 4: The Lie bracket and the Lie derivative

Overview

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.

LieBracket

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.

M >	X := evalDG(xD_x + yD_y);

(2.1)

M >	Y := evalDG(xyD_z);

(2.2)

M >	LieBracket(X, Y);

(2.3)

LieDerivative

The DifferentialGeometry command LieDerivative may be applied to Maple expressions, vectors, forms, tensors, and connections.

M >	with(DifferentialGeometry):

M >	DGsetup([x, y, z], "M"):

Define a vector field X and calculate the Lie derivative of some DifferentialGeometry objects.

M >	X := evalDG(xD_x + yD_y);

(3.1)

[1] Functions

M >	f := x^2 - y^2;

(3.2)

M >	LieDerivative(X, f);

(3.3)

[2] Vector Fields

M >	Y := evalDG(xyD_z);

(3.4)

M >	LieDerivative(X, Y);

(3.5)

In this case, the LieDerivative agrees with the Lie bracket.

M >	LieBracket(X, Y);

(3.6)

[3] Differential Forms

M >	alpha := evalDG(zdy - ydz);

(3.7)

M >	LieDerivative(X, alpha);

(3.8)

[4] Tensors

M >	T := evalDG(dx &t dx &t dx);

(3.9)

M >	LieDerivative(X, T);

(3.10)

Application 1 -- Integrable distributions

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.

M >	with(DifferentialGeometry): DGsetup([x, y, z, u, v], E5);

(4.1)

E5 >	X1 := evalDG(zuD_x - 2xzD_z + 2vxD_v);

(4.2)

E5 >	X2 := evalDG(zD_y - 2y*D_v);

(4.3)

E5 >	X3 := evalDG(-zD_z + uD_u + v*D_v);

(4.4)

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.

E5 >	Y := DGbasis([X1, X2, X3]);

(4.5)

E5 >

nops(Y);

(4.6)

Next, we compute all possible brackets and check that they are in the span of the vectors {X1, X2, X3}.

E5 >	X12 := LieBracket(X1, X2):

E5 >	X13 := LieBracket(X1, X3):

E5 >	X23 := LieBracket(X2, X3):

E5 >	GetComponents(X12, [X1, X2, X3]);

(4.7)

E5 >	GetComponents(X13, [X1, X2, X3]);

(4.8)

E5 >	GetComponents(X23, [X1, X2, X3]);

(4.9)

We remark that that these calculations can be done with just a single call to GetComponents.

E5 >	GetComponents([X12, X13, X23], [X1, X2, X3]);

(4.10)

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.

E5 >	C := Annihilator([X1, X2, X3]);

(4.11)

E5 >	f := (i,j) -> Hook([X12, X13, X23][i], C[j]);

(4.12)

E5 >	Matrix(3, 2, f);

(4.13)

Application 2 -- Integrable distributions

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}.

E5 >

f := 'f':

E5 >	Eq := map(LieDerivative, [X1, X2, X3], f(x, y, z, u, v));

(5.1)

A very useful command for improving the output of these computations is the PDEtools command declare.

E5 >	PDEtools[declare](f(x, y, z, u, v));

(5.2)

E5 >

Eq;

(5.3)

E5 >	pdsolve(Eq, f(x, y, z, u, v));

${f = _F1(z*u+x^2, v*z+y^2)}$

(5.4)

We conclude that a pair of fundamental solutions are.

E5 >	f1 := x^2 + zu: f2 := y^2 + zv:

Check these results using the LieDerivative command.

E5 >	check := [seq(seq(LieDerivative(X, f), X=[X1, X2, X3]), f=[f1, f2])];

(5.5)

Check these results using the pdetest command.

E5 >	pdetest(f(x, y, z, u, v) = f1, Eq);

(5.6)

E5 >	pdetest(f(x, y, z, u, v) = f2, Eq);

(5.7)

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.

DGmap

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.

E5 >	with(DifferentialGeometry):

E5 >	DGsetup([x, y], E2);

Define a vector field X, depending upon parameter t.

E5 >	X := evalDG( xD_x + ty*D_y);

(6.1)

Add 2 to each coefficient of X.

E2 >	Tools:-DGmap(1, a -> a + 2, X);

(6.2)

Differentiate each coefficient of X with respect to t.

E2 >	Tools:-DGmap(1, diff, X ,t);

(6.3)

Integrate each coefficient of X with respect to t from 0 to 1.

E2 >	Tools:-DGmap(1, int, X, t = 0 .. 1);

(6.4)

Application 3 -- Killing Vector Fields

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.

E2 >	with(DifferentialGeometry):

E2 >	DGsetup([x, y], E2);

(7.1)

Define the metric g for the Poincare half-plane.

E2 >	g := (1/y^2) &mult evalDG(dx &t dx + dy &t dy);

(7.2)

Define a general vector on E2.

E2 >	X := evalDG(a(x, y)D_x + b(x, y)D_y);

(7.3)

E2 >	PDEtools[declare](a(x, y), b(x, y));

(7.4)

Calculate the Lie derivative of the metric g with respect to the vector field X.

E2 >	LD := LieDerivative(X, g);

LD := 2*(a[x]*y-b)*dx*dx/y^3+(b[x]+a[y])*dx*dy/y^2+(b[x]+a[y])*dy*dx/y^2+2*(b[y]*y-b)*dy*dy/y^3

(7.5)

Extract the coefficients of the Lie derivative LD to obtain the Killing equations for the metric.

E2 >	KillingEq := Tools:-DGinfo(LD, "CoefficientSet");

$KillingEq := {2*(b[y]*y-b)/y^3, 2*(a[x]*y-b)/y^3, (b[x]+a[y])/y^2}$

(7.6)

Solve the Killing equations with pdsolve.

E2 >	soln := pdsolve(KillingEq, {a(x, y), b(x, y)});

$soln := {b = (_C1*x+_C2)*y, a = (-y^2+x^2)*_C1/2+_C2*x+_C3}$

(7.7)

Substitute the solution obtained by pdsolve back into the vector field X.

E2 >	newX := eval(X, soln);

(7.8)

We use the DGmap utility (see previous section) to generate the 3 Killing vectors associated to the constants _C1, _C2, _C3.

E2 >	X1 := Tools:-DGmap(1, diff, newX, _C1);

(7.9)

E2 >	X2 := Tools:-DGmap(1, diff, newX, _C2);

(7.10)

E2 >	X3 := Tools:-DGmap(1, diff, newX, _C3);

(7.11)

E2 >	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.

E2 >	GetComponents(LieBracket(X1, X2), Gamma, method = "real");

(7.12)

E2 >	GetComponents(LieBracket(X1, X3), Gamma, method = "real");

(7.13)

E2 >	GetComponents(LieBracket(X2, X3), Gamma, method = "real");

(7.14)

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.

Exercises

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.

E3 >	with(DifferentialGeometry):

E5 >	DGsetup([x, y, z], M):

M >	X := evalDG(x* D_x - yzD_y);

(8.1.1)

M >	Y := evalDG(z^2xD_z);

(8.1.2)

M >	f := sin(xy) + tan(yz);

(8.1.3)

M >	alpha := evalDG(z*dx &w dy - dy &w dz);

(8.1.4)

M >	beta := evalDG(dx &w dy &w dz);

(8.1.5)

M >	T := evalDG(z*dx &t D_y &t dz);

(8.1.6)

Solution

[i] the Lie bracket of X and Y.

M >	LieBracket(X, Y);

(8.1.1.1)

[ii] the iterated Lie bracket [X, [X, [X, Y]]].

M >	X3 := LieBracket(X, LieBracket(X, LieBracket(X, Y)));

(8.1.1.2)

M >	X4 := LieBracket(X, X3);

(8.1.1.3)

M >	LieBracket(X, X4);

(8.1.1.4)

[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.

M >	LieBracket(X, x^2yY - xyX);

(8.1.1.5)

[iv] the Lie derivative of f with respect to X.

M >	LieDerivative(X, f);

(8.1.1.6)

[v] the Lie derivative of beta with respect to X.

M >	LieDerivative(X, beta);

(8.1.1.7)

[vi] the Lie derivative with respect to Y of the interior product of X and alpha.

M >	LieDerivative(Y, Hook(X, alpha));

(8.1.1.8)

[vii] the Lie derivative of the tensor product of T with X with respect to X.

M >	LieDerivative(X, T &t X);

(8.1.1.9)

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.

M >	with(DifferentialGeometry):

Solution

Here are the programs:

[i] [X, Y] = - [Y, X].

E2 >	LieBracketSkewSymmetric := proc(X, Y)

E2 >

local a;

E2 >	a := LieBracket(X, Y) &plus LieBracket(Y, X);

E2 >	Tools:-DGinfo(a, "CoefficientSet");

E3 >

end:

[ii] [X, f*Y] = X(f)*Y + f* [X, Y].

E2 >	LieBracketDerivation := proc(X, Y, f)

E2 >	local a, b, b1, b2, c;

E2 >	a := LieBracket(X, f &mult Y);

E2 >	b1 := LieDerivative(X, f) &mult Y;

E2 >	b2 := f &mult LieBracket(X, Y);

E2 >	b := b1 &plus b2;

E2 >	c := a &minus b;

E2 >	Tools:-DGinfo(c, "CoefficientSet");

E3 >

end:

[iii] [X, [Y, Z]] + [Z, [X, Y]] + [ Y, [Z, X]] = 0.

E2 >	LieBracketJacobi := proc(X, Y, Z)

E2 >	local a, a1, a2, a3;

E2 >	a1 := LieBracket(X, LieBracket(Y, Z));

E2 >	a2 := LieBracket(Z, LieBracket(X, Y));

E2 >	a3 := LieBracket(Y, LieBracket(Z, X));

E2 >	a := a1 &plus a2 &plus a3;

E2 >	Tools:-DGinfo(a,"CoefficientSet");

E2 >

end:

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.

E2 >	LieDerivativeDerivation := proc(X, T, S)

E2 >	local DGobject, M, a, b, b1, b2, c;

E2 >	DGobject := Tools:-DGinfo(T, "ObjectType");

E2 >	if DGobject = "form" then

E2 >	M := (x, y) -> x &wedge y;

E2 >

else

E2 >	M := (x, y) -> x &tensor y;

E2 >

fi;

E2 >	a := LieDerivative(X, M(T, S));

E2 >	b1 := M(LieDerivative(X, T), S);

E2 >	b2 := M(T, LieDerivative(X, S));

E2 >	b := b1 &plus b2;

E2 >	c := a &minus b;

E2 >	Tools:-DGinfo(c, "CoefficientSet");

E3 >

end:

[vi] L_X(Hook(Y, alpha)) = Hook([X, Y], alpha) + Hook(Y, L_X(alpha))

M >	LieDerivativeHook := proc(X, Y, alpha)

M >	local a, a1, b, b1, b2, b3, b4, c;

M >	a1 := Hook(Y, alpha);

M >	a := LieDerivative(X, a1);

M >	b1 := LieBracket(X, Y);

M >	b2 := Hook(b1, alpha);

M >	b3 := LieDerivative(X, alpha);

M >	b4 := Hook(Y, b3);

M >	b := b2 &plus b4;

M >	c := a &minus b;

M >	Tools:-DGinfo(c, "CoefficientSet");

E3 >

end:

[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.

E2 >	LieDerivativeCommutator := proc(X, Y, T)

E2 >	local a, a1, a2, b, b1, c;

E2 >	a1 := LieDerivative(X, LieDerivative(Y, T));

E2 >	a2 := LieDerivative(Y, LieDerivative(X, T));

E3 >	a := a1 &minus a2;

E2 >	b1 := LieBracket(X, Y);

E2 >	b := LieDerivative(b1, T);

E2 >	c := a &minus b;

E2 >	Tools:-DGinfo(c, "CoefficientSet");

E3 >

end:

Here is some test data.

E3 >	DGsetup([x, y, z], E3);

(8.2.1.1)

E3 >	X1 := evalDG(yzD_x - (x^2 + y^2)D_y + 3D_z);

(8.2.1.2)

E3 >	X2 := evalDG(D_x + x^2D_y - xy*D_z);

(8.2.1.3)

E3 >	X3 := evalDG(z^2D_x - x^2D_y + D_z);

(8.2.1.4)

E3 >	f := x*y/z^2;

(8.2.1.5)

E3 >	alpha1 := evalDG(x^2dx &w dy - (y/z)dy &w dz);

(8.2.1.6)

E3 >	alpha2 := evalDG(zdx + xdy);

(8.2.1.7)

E3 >	T1 := evalDG(zdx &t D_y + x^2dy &t D_z);

(8.2.1.8)

E3 >	T2 := evalDG(zD_x &t D_y + x^2D_z &t D_z);

(8.2.1.9)

Here are some tests of the identities.

E3 >	LieBracketSkewSymmetric(X1, X2);

(8.2.1.10)

E3 >	LieBracketDerivation(X1, X2, f);

(8.2.1.11)

E3 >	LieBracketJacobi(X1, X2, X3);

(8.2.1.12)

E3 >	LieDerivativeDerivation(X1, alpha1, alpha2);

(8.2.1.13)

E3 >	LieDerivativeDerivation(X2, T1, T2);

(8.2.1.14)

E3 >	LieDerivativeHook(X1, X2, alpha1);

(8.2.1.15)

E3 >	LieDerivativeCommutator(X1, X2, alpha1);

(8.2.1.16)

E3 >	LieDerivativeCommutator(X2, X3, T2);

(8.2.1.17)

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.

E3 >	with(DifferentialGeometry):

>	DGsetup([x, y, z, u, v, w], E6):

E6 >	Va := evalDG([zuD_x - 2xzD_z + 2vxD_v, zD_y - 2yD_v, -zD_z + uD_u + vD_v]);

(8.3.1)

E6 >	Vb := evalDG([D_x, D_y + x*D_z]);

(8.3.2)

E6 >	Vc := evalDG([xD_u - yD_v, yD_u + xD_v, -xD_x - yD_y + zD_v, yD_x - xD_y - zD_u]);

(8.3.3)

E6 >	Vd := evalDG([D_u, D_x + zD_y + uD_z + exp(y)D_v + exp(y)v*D_w]);

(8.3.4)

Solution

Part [i]

M >	DerivedDistribution := proc(V)

M >	local V1, V2, p, i, j, k;

M >	p := nops(V);

M >	V1 := Array(1 .. p*(p + 1)/2);

M >	for i to p do

M >	V1[i] := V[i]

M >

od;

M >

k := p;

M >	for i to p do

M >	for j from i + 1 to p do

M >	k := k + 1;

M >	V1[k] := LieBracket(V[i], V[j]);

M >

od;

M >

od;

M >	V2 := convert(V1, list);

M >	DGbasis(V2);

E6 >

end:

Part [ii]

M >	CheckIntegrable := proc(V1)

M >	local p, i, j, ans, Z;

M >	p := nops(V1):

M >	for i to p do

M >	for j from i + 1 to p do

M >	Z := LieBracket(V1[i], V1[j]);

M >	ans := GetComponents(Z, V1);

M >	if ans = [] then return(false, i, j) fi;

M >

od;

M >

od;

M >

true;

E6 >

end:

Example 1. The distribution of vectors Va is integrable.

E6 >	CheckIntegrable(Va);

(8.3.1.1)

Example 2. The distribution of vectors Vb is not integrable. The derived distribution of Vb is integrable.

E6 >	CheckIntegrable(Vb);

(8.3.1.2)

E6 >	Vb1 := DerivedDistribution(Vb);

(8.3.1.3)

E6 >	CheckIntegrable(Vb1);

(8.3.1.4)

Example 3. The distribution of vectors Vc is integrable.

E6 >	CheckIntegrable(Vc);

(8.3.1.5)

Example 4. The distribution of vectors Vd is not integrable. We must calculate several derived distributions before arriving at an integrable one.

E6 >	CheckIntegrable(Vd);

E6 >	Vd1 := DerivedDistribution(Vd);

(8.3.1.6)

E6 >	CheckIntegrable(Vd1);

(8.3.1.7)

E6 >	Vd2 := DerivedDistribution(Vd1);

(8.3.1.8)

E6 >	CheckIntegrable(Vd2);

(8.3.1.9)

E6 >	Vd3 := DerivedDistribution(Vd2);

(8.3.1.10)

E6 >	CheckIntegrable(Vd3);

(8.3.1.11)

Exercise 4

Show that the vector fields Gamma define a real 4 dimensional Lie algebra (with Lie bracket given by LieBracket).

E6 >	with(DifferentialGeometry):

E6 >	DGsetup([w,x,y,z], E4);

E6 >	Gamma := evalDG([D_w, D_x, xD_w + D_y, (1/2y^2 + 2w)D_w + (y + x)D_x + yD_y + D_z]);

(8.4.1)

Solution

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.

E4 >	F := (i,j) -> GetComponents(LieDerivative(Gamma[i], Gamma[j]), Gamma, method = "real");

F := proc ({ i, j }) options operator, arrow; DifferentialGeometry:-LinearCombo(DifferentialGeometry:-LieDerivative(Gamma[i], Gamma[j]), Gamma, method = "real") end proc

(8.4.1.1)

E4 >	Answer := Matrix(4, 4, (i, j) -> F(i, j));

(8.4.1.2)

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.

E4 >	with(DifferentialGeometry): DGsetup([w, x, y, z], E4);

(8.5.1)

E4 >	Gamma := evalDG([D_w, D_x, xD_w + D_y, (1/2y^2 + 2w)D_w + (y + x)D_x + yD_y + D_z]);

(8.5.2)

Solution

E4 >	vars:=x, y, z, w;

(8.5.1.1)

E4 >	PDETools[declare](a1(vars), a2(vars), a3(vars), a4(vars));

(8.5.1.2)

E4 >	Z := DGzip([a1(vars), a2(vars), a3(vars), a4(vars)], [D_x, D_y, D_z, D_w], "plus");

(8.5.1.3)

E4 >	EQ := {seq(Tools:-DGinfo(LieBracket(Z, X), "CoefficientSet"), X = Gamma)};

$EQ := {{-(1/2)*(a4[w]*y^2)-2*a4[w]*w-a4[x]*y-a4[x]*x-y*a4[y]-a4[z]+2*a4+a2*y, -(1/2)*(a1[w]*y^2)-2*a1[w]*w-a1[x]*y-a1[x]*x-y*a1[y]-a1[z]+a1+a2, -(1/2)*(a2[w]*y^2)-2*a2[w]*w-a2[x]*y-a2[x]*x-y*a2[y]-a2[z]+a2, -(1/2)*(a3[w]*y^2)-2*a3[w]*w-a3[x]*y-a3[x]*x-y*a3[y]-a3[z]}, {-a4[x], -a2[x], -a1[x], -a3[x]}, {-a3[w], -a2[w], -a1[w], -a4[w]}, {-x*a4[w]-a4[y]+a1, -x*a3[w]-a3[y], -x*a2[w]-a2[y], -x*a1[w]-a1[y]}}$

(8.5.1.4)

E4 >	EQ := map(op, EQ);

$EQ := {-(1/2)*(a4[w]*y^2)-2*a4[w]*w-a4[x]*y-a4[x]*x-y*a4[y]-a4[z]+2*a4+a2*y, -(1/2)*(a1[w]*y^2)-2*a1[w]*w-a1[x]*y-a1[x]*x-y*a1[y]-a1[z]+a1+a2, -(1/2)*(a2[w]*y^2)-2*a2[w]*w-a2[x]*y-a2[x]*x-y*a2[y]-a2[z]+a2, -x*a4[w]-a4[y]+a1, -x*a3[w]-a3[y], -x*a2[w]-a2[y], -x*a1[w]-a1[y], -a4[x], -a3[w], -a2[w], -a1[w], -a4[w], -a2[x], -a1[x], -a3[x], -(1/2)*(a3[w]*y^2)-2*a3[w]*w-a3[x]*y-a3[x]*x-y*a3[y]-a3[z]}$

(8.5.1.5)

E4 >	soln := pdsolve(EQ, {a1(vars), a2(vars), a3(vars), a4(vars)});

$soln := {a1 = (_C2*z+_C3)*exp(z), a4 = y*(_C2*z+_C3)*exp(z)+_C4*exp(2*z), a3 = _C1, a2 = _C2*exp(z)}$

(8.5.1.6)

E4 >	newZ := eval(Z, soln);

(8.5.1.7)

E4 >	Answer := [seq(Tools:-DGmap(1, diff, newZ, cat(_C, i)), i = 1 .. 4)];

(8.5.1.8)

Let's check this result.

E4 >	Matrix(4, 4, (i, j)->LieBracket(Gamma[i], Answer[j]));

(8.5.1.9)

Exercise 6

Find the Killing vectors for the following metrics.

E4 >	with(DifferentialGeometry):

[i] This is the metric for a two-dimensional space of constant curvature.

E4 >	DGsetup([u, v], M2);

(8.6.1)

M2 >	g1 := evalDG( 1/(1 + k/4(u^2 + v^2))^2(du &t du + dv &t dv));

g1 := 16*du*du/(4+k*u^2+k*v^2)^2+16*dv*dv/(4+k*u^2+k*v^2)^2

(8.6.2)

[ii] This is the Godel solution to the Einstein equations.

M2 >	DGsetup([x ,y, z, t], M4);

(8.6.3)

M4 >	tau := evalDG(dt + exp(x)*dz);

(8.6.4)

M4 >	g2 := evalDG(dx &t dx + dy &t dy + 1/2exp(2x)*dz &t dz - tau &t tau);

(8.6.5)

Solution

Part [i]

M4 >	ChangeFrame(M2):

Define a general vector field X.

M2 >	PDEtools[declare](a(u, v), b(u, v), quiet);

M2 >	X := evalDG(a(u, v)D_u + b(u, v)D_v);

(8.6.1.1)

Calculate the Lie derivative of the metric g1 with respect to X.

M2 >	LD := LieDerivative(X, g1);

LD := 32*(4*a[u]+a[u]*k*u^2+a[u]*k*v^2-2*a*k*u-2*b*k*v)*du*du/(4+k*u^2+k*v^2)^3+16*(b[u]+a[v])*du*dv/(4+k*u^2+k*v^2)^2+16*(b[u]+a[v])*dv*du/(4+k*u^2+k*v^2)^2+32*(4*b[v]+b[v]*k*u^2+b[v]*k*v^2-2*a*k*u-2*b*k*v)*dv*dv/(4+k*u^2+k*v^2)^3

(8.6.1.2)

Extract the coefficients of the Lie derivative LD.

M2 >	KillingEq := Tools:-DGinfo(LD, "CoefficientSet");

$KillingEq := {32*(4*b[v]+b[v]*k*u^2+b[v]*k*v^2-2*a*k*u-2*b*k*v)/(4+k*u^2+k*v^2)^3, 32*(4*a[u]+a[u]*k*u^2+a[u]*k*v^2-2*a*k*u-2*b*k*v)/(4+k*u^2+k*v^2)^3, 16*(b[u]+a[v])/(4+k*u^2+k*v^2)^2}$

(8.6.1.3)

Solve for the unknown coefficients a(u, v), b(u, v).

M2 >	soln := pdsolve(KillingEq, {a(u, v), b(u, v)});

$soln := {a = (4*k^2*u*v*_C3+((u^2-v^2)*_C1-2*v*_C2)*k+4*_C1)/(2*k), b = (4-k*u^2+k*v^2)*_C3+(_C1*v+_C2)*u}$

(8.6.1.4)

M2 >	newX := eval(X, soln);

newX := (4*k^2*u*v*_C3+((u^2-v^2)*_C1-2*v*_C2)*k+4*_C1)*D_u/(2*k)+((4-k*u^2+k*v^2)*_C3+(_C1*v+_C2)*u)*D_v

(8.6.1.5)

We use the DGmap utility to generate the 3 Killing vectors associated to the constants _C1, _C2, _C3.

M2 >	X1 := Tools:-DGmap(1, diff, newX, _C1);

(8.6.1.6)

M2 >	X2 := Tools:-DGmap(1, diff, newX, _C2);

(8.6.1.7)

M2 >	X3 := Tools:-DGmap(1, diff, newX, _C3);

(8.6.1.8)

The Killing vectors for the metric g1 are

M2 >	Answer1 := [X1, X2, X3];

AnswerA := [(k^2/2+u^2/2-v^2/2)*D_u+u*v*D_v, -v*D_u+u*D_v, -2*u*v*D_u+(u^2-k^2-v^2)*D_v]

(8.6.1.9)

Part [ii]

M2 >	ChangeFrame(M4):

M4 >	vars := x, y ,z, t:

M4 >	unknowns := [a1, a2, a3, a4](vars):

M4 >	PDEtools[declare](unknowns, quiet);

M4 >	X := DGzip(unknowns, [D_x, D_y, D_z, D_t], "plus");

(8.6.1.10)

M4 >	LD := LieDerivative(X, g2);

(8.6.1.11)

M4 >	KillingEq := Tools:-DGinfo(LD, "CoefficientSet");

KillingEq := {-2*a4[z]*exp(x)-a3[z]*exp(2*x)-a1*exp(2*x), a2[x]+a1[y], -a4[y]*exp(x)+a2[z]-(1/2)*(a3[y]*exp(2*x)), -a4[x]-a3[x]*exp(x)+a1[t], -a4[x]*exp(x)-(1/2)*(a3[x]*exp(2*x))+a1[z], -a4[y]+a2[t]-a3[y]*exp(x), 2*a1[x], 2*a2[y], -2*a4[t]-2*a3[t]*exp(x), -a4[t]*exp(x)-a4[z]-(1/2)*(a3[t]*exp(2*x))-a3[z]*exp(x)-a1*exp(x)}

(8.6.1.12)

M4 >	soln := pdsolve(KillingEq, convert(unknowns, set));

$soln := {a2 = _C1, a1 = _C2*z+_C3, a3 = -_C2*z^2/2-_C3*z+_C2*exp(-2*x)+_C5, a4 = -2*_C2*exp(-x)+_C4}$

(8.6.1.13)

M4 >	newX := eval(X, soln);

newX := (_C2*z+_C3)*D_x+_C1*D_y+(-_C2*z^2/2-_C3*z+_C2*exp(-2*x)+_C5)*D_z+(-2*_C2*exp(-x)+_C4)*D_t

(8.6.1.14)

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

M4 >	Answer2 := [seq(Tools:-DGmap(1, diff, newX, _C\|\|i), i = 1 .. 5)];

(8.6.1.15)

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.

M4 >	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].

P >	Gamma1:= evalDG([exp(-x3)D_x1 - exp(-x3)x2^2D_x2 - 2exp(-x3)x2D_x3, D_x3, exp(x3)*D_x2, D_x1]);

(8.7.1)

[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].

P >	Gamma2 := evalDG([D_x2, D_x3, x3D_x2 - exp(x1)D_x3, D_x1 + x2D_x2 + x3D_x3, exp(-x1)D_x1 + (kx1 - 1/2exp(-2x4))D_x2 + exp(-x1)D_x4]);

Gamma2 := [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]

(8.7.2)

[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].

P >	Gamma3 := [D_x1, D_x2, (x1^2 - x2^2 - x3^2 + x4^2)D_x1 + 2x1x2D_x2 + 2x1x3D_x3 + 2x1x4D_x4, 2x1x2D_x1 + (x2^2 - x1^2 - x3^2 + x4^2)D_x2 + 2x3x2D_x3 + 2x4x2D_x4, x2D_x1 - x1D_x2, x1D_x1 + x2D_x2 + x3D_x3 + x4D_x4];

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]

(8.7.3)

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.

P >	vars := x1, x2, x3, x4;

(8.7.1.1)

P >	EQ1 := {seq(LieDerivative(X, f(vars)), X = Gamma1)};

$EQ1 := {exp(-x3)*f[x1]-exp(-x3)*x2^2*f[x2]-2*exp(-x3)*x2*f[x3], f[x1], f[x3], exp(x3)*f[x2]}$

(8.7.1.2)

P >	pdsolve(EQ1);

${f(x1, x2, x3, x4) = _F1(x4)}$

(8.7.1.3)

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.

P >	unknowns := seq(a\|\|i(vars), i = 1 .. 4):

P >	PDEtools[declare](unknowns, quiet);

P >	alpha := DGzip([unknowns], [dx1, dx2, dx3, dx4], "plus");

(8.7.1.4)

Lie differentiate alpha with respect to each vector in Gamma1 and get the coefficients of the result.

P >	EQ2 := {seq(Tools:-DGinfo(LieDerivative(X, alpha), "CoefficientSet"), X = Gamma1)}:

P >	InvariantOneFormEquations := map(op, EQ2);

$InvariantOneFormEquations := {exp(x3)*a1[x2], exp(x3)*a2[x2], exp(x3)*a4[x2], -exp(-x3)*(2*a3+2*x2*a2-a2[x1]+x2^2*a2[x2]+2*x2*a2[x3]), a2[x3], a3[x1], a3[x3], a2[x1], a1[x1], a1[x3], -exp(-x3)*(-a1[x1]+x2^2*a1[x2]+2*x2*a1[x3]), a4[x1], a4[x3], -exp(-x3)*(-a4[x1]+x2^2*a4[x2]+2*x2*a4[x3]), exp(x3)*(a2+a3[x2]), exp(-x3)*(2*x2*a3+x2^2*a2-a1+a3[x1]-x2^2*a3[x2]-2*x2*a3[x3])}$

(8.7.1.5)

P >	pdsolve(InvariantOneFormEquations);

${a1 = 0, a4 = _F1(x4), a3 = -x2*_F2(x4), a2 = _F2(x4)}$

(8.7.1.6)

We conclude that a basis for the invariant 1-forms is Omega = [dx2 - x2dx3, dx4]. Let's check this result.

P >	Omega := evalDG([dx2 - x2*dx3, dx4]);

(8.7.1.7)

P >	Matrix(2, 4, (i, j) -> LieDerivative(Gamma1[j], Omega[i]));

(8.7.1.8)

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?

P >	S0 := Tensor:-GenerateSymmetricTensors(Omega, 2);

S0 := [dx2*dx2-x2*dx2*dx3-x2*dx3*dx2+x2^2*dx3*dx3, dx2*dx4/2-x2*dx3*dx4/2+dx4*dx2/2-x2*dx4*dx3/2, dx4*dx4]

(8.7.1.9)

First, we create the general invariant symmetric tensor.

P >	unknowns := seq(b\|\|i(vars), i = 1 .. 10):

P >	PDEtools[declare](unknowns, quiet);

P >	S := Tensor:-GenerateSymmetricTensors([dx1, dx2, dx3, dx4], 2):

P >	g := DGzip([unknowns], S, "plus");

g := b1*dx1*dx1+b2*dx1*dx2/2+b3*dx1*dx3/2+b4*dx1*dx4/2+b2*dx2*dx1/2+b5*dx2*dx2+b6*dx2*dx3/2+b7*dx2*dx4/2+b3*dx3*dx1/2+b6*dx3*dx2/2+b8*dx3*dx3+b9*dx3*dx4/2+b4*dx4*dx1/2+b7*dx4*dx2/2+b9*dx4*dx3/2+b10*dx4*dx4

(8.7.1.10)

Lie differentiate g with respect to each vector in Gamma1 and get the coefficients of the result.

P >	EQ3 := {seq(Tools:-DGinfo(LieDerivative(X, g), "CoefficientSet"), X = Gamma1)}:

P >	InvariantSymmetricTensorEq := map(op, EQ3);

(8.7.1.11)

P >	soln := pdsolve(InvariantSymmetricTensorEq);

$soln := {b8 = x2^2*_F3(x4)-(1/4)*_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)}$

(8.7.1.12)

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.

P >	newg := Tools:-DGsimplify(eval(g, soln));

newg := (1/2)*(_F4(x4)*dx1*dx2)-(1/2)*(x2*_F4(x4)*dx1*dx3)+(1/2)*(_F4(x4)*dx2*dx1)+_F3(x4)*dx2*dx2-x2*_F3(x4)*dx2*dx3+(1/2)*(_F2(x4)*dx2*dx4)-(1/2)*(x2*_F4(x4)*dx3*dx1)-x2*_F3(x4)*dx3*dx2+(x2^2*_F3(x4)-(1/4)*_F4(x4))*dx3*dx3-(1/2)*(x2*_F2(x4)*dx3*dx4)+(1/2)*(_F2(x4)*dx4*dx2)-(1/2)*(x2*_F2(x4)*dx4*dx3)+_F1(x4)*dx4*dx4

(8.7.1.13)

P >	g1 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 1, _F2(x4) = 0, _F3(x4) = 0, _F4(x4) = 0}));

(8.7.1.14)

P >	g2 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 0, _F2(x4) = 1, _F3(x4) = 0, _F4(x4) = 0}));

(8.7.1.15)

P >	g3 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 0, _F2(x4) = 0, _F3(x4) = 1, _F4(x4) = 0}));

(8.7.1.16)

P >	g4 := Tools:-DGsimplify(eval(newg, {_F1(x4) = 0, _F2(x4) = 0, _F3(x4) = 1, _F4(x4) = 1}));

g4 := dx1*dx2/2-x2*dx1*dx3/2+dx2*dx1/2+dx2*dx2-x2*dx2*dx3-x2*dx3*dx1/2-x2*dx3*dx2+(x2^2-1/4)*dx3*dx3

(8.7.1.17)

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).

P >	Answer1 := [op(S0), g4 &minus S0[1]];

Answer1 := [dx2*dx2-x2*dx2*dx3-x2*dx3*dx2+x2^2*dx3*dx3, dx2*dx4/2-x2*dx3*dx4/2+dx4*dx2/2-x2*dx4*dx3/2, dx4*dx4, dx1*dx2/2-x2*dx1*dx3/2+dx2*dx1/2-x2*dx3*dx1/2-dx3*dx3/4]

(8.7.1.18)

Check that all the tensors in Answer1 are invariant.

P >	Matrix(4, 4, (i, j) -> LieDerivative(Gamma1[i], Answer1[j]));

(8.7.1.19)

Summary: The most general invariant metric is

P >	g := DGzip([a1(x4), a2(x4), a3(x4), a4(x4)], Answer1, "plus");

g := (1/2)*(a4(x4)*dx1*dx2)-(1/2)*(a4(x4)*x2*dx1*dx3)+(1/2)*(a4(x4)*dx2*dx1)+a1(x4)*dx2*dx2-a1(x4)*x2*dx2*dx3+(1/2)*(a2(x4)*dx2*dx4)-(1/2)*(a4(x4)*x2*dx3*dx1)-a1(x4)*x2*dx3*dx2+(-(1/4)*a4(x4)+a1(x4)*x2^2)*dx3*dx3-(1/2)*(a2(x4)*x2*dx3*dx4)+(1/2)*(a2(x4)*dx4*dx2)-(1/2)*(a2(x4)*x2*dx4*dx3)+a3(x4)*dx4*dx4

(8.7.1.20)

The calculations for problems [ii] and [iii] follow exactly the same steps. Here are the answers.

Part [ii]

P >	InvariantFunctions := [];

(8.7.1.21)

P >	InvariantOneForms := evalDG([exp(x4)*dx1, dx1 - dx4]);

(8.7.1.22)

P >	Matrix(2, 5, (i, j) -> LieDerivative(Gamma2[j], InvariantOneForms[i]));

(8.7.1.23)

P >

InvariantSymmetricTensors := evalDG([exp(2*x4)*dx1 &t dx1, exp(x4)*dx1 &t dx1 - 1/2*exp(x4)*dx1 &t dx4 - 1/2*exp(x4)*dx4 &t dx1, dx1 &t dx1 - dx1 &t dx4 - dx4 &t dx1 + dx4 &t dx4, -2*k*exp(2*x4)*x4*dx1 &t dx1 + exp(-x1 + 2*x4)*dx1 &t dx2 + exp(-x1 + 2*x4)*dx2 &t dx1 + exp(2*x4 - 2*x1)*dx3 &t dx3 + dx4 &t dx4]);

InvariantSymmetricTensors := [exp(2*x4)*dx1*dx1, exp(x4)*dx1*dx1-(1/2)*(exp(x4)*dx1*dx4)-(1/2)*(exp(x4)*dx4*dx1), dx1*dx1-dx1*dx4-dx4*dx1+dx4*dx4, -2*k*exp(2*x4)*x4*dx1*dx1+exp(-x1+2*x4)*dx1*dx2+exp(-x1+2*x4)*dx2*dx1+exp(2*x4-2*x1)*dx3*dx3+dx4*dx4]

(8.7.1.24)

P >	Matrix(4, 5, (i, j) -> LieDerivative(Gamma2[j], InvariantSymmetricTensors[i]));

(8.7.1.25)

Part [iii]

P >	InvariantFunctions := [x4/x3];

(8.7.1.26)

P >	Matrix(1, 6, (i, j) -> LieDerivative(Gamma3[j], InvariantFunctions[i]));

(8.7.1.27)

P >	InvariantOneForms := evalDG([-1/x3dx3 + 1/x4dx4]);

(8.7.1.28)

P >	Matrix(1, 6, (i, j) -> LieDerivative(Gamma3[j], InvariantOneForms[i]));

(8.7.1.29)

P >	InvariantSymmetricTensors := evalDG([1/x3^2dx3 &t dx3 - 1/x3/x4dx3 &t dx4-1/x3/x4dx4 &t dx3 + 1/x4^2dx4 &t dx4, 1/(x4^2 + x3^2)dx1 &t dx1 + 1/(x4^2 + x3^2)dx2 &t dx2 + 1/x3^2dx3 &t dx3 - x4/x3/(x4^2 + x3^2)dx3 &t dx4 - x4/x3/(x4^2 + x3^2)*dx4 &t dx3]);

InvariantSymmetricTensors := [dx3*dx3/x3^2-dx3*dx4/(x3*x4)-dx4*dx3/(x3*x4)+dx4*dx4/x4^2, dx1*dx1/(x4^2+x3^2)+dx2*dx2/(x4^2+x3^2)+dx3*dx3/x3^2-x4*dx3*dx4/(x3*(x4^2+x3^2))-x4*dx4*dx3/(x3*(x4^2+x3^2))]