Lesson 3: Utilities - Maple Help

All Products Maple MapleSim

Home : Support : Online Help : Mathematics : DifferentialGeometry : Lessons and Tutorials : DifferentialGeometry : Lesson 3: Utilities

DifferentialGeometry Lessons

Lesson 3: Some DifferentialGeometry Utilities

Overview

DGinfo/CoefficientSet, DGinfo/CoefficientList

GetComponents

GenerateForms, GenerateTensors, GenerateSymmetricTensors

Overview

DifferentialGeometry includes a powerful set of utilities for performing linear algebra computations on spaces of vectors, differential forms, and tensors (VFT).

In this lesson, you will learn to do the following:

–	Extract the set of coefficients of a DifferentialGeometry VFT.

–	Extract specific coefficients of a DifferentialGeometry VFT.

–	Determine if a given VFT is a linear combination of a set of VFT.

–	Create a spanning list of independent VFT (a basis) from a list of VFT.

–	Generate a basis for the space of p-forms.

–	Generate a collection of tensors.

–	Extend a given set of independent VFT to a basis for a subspace.

–	Find the dual basis for the cotangent space from a basis for the tangent space.

–	Find the annihilator subspace for a given set of vectors or forms.

DGinfo/CoefficientSet, DGinfo/CoefficientList

The command DGinfo can be used to extract all or some of the coefficients of a vector, differential form or tensor. Exercises 11 illustrates the use of these commands in programming differential geometry applications.

>	with(DifferentialGeometry): with(Tools):

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

$frame name: M$

(2.1)

Define a vector X = aD_x + bD_y + bD_z

M >	X := evalDG(aD_x + bD_y + b*D_z);

$X := a D_x + b D_y + b D_z$

(2.2)

Find the set of coefficients of X.

M >	DGinfo(X, "CoefficientSet");

$\{a, b\}$

(2.3)

Find the list of all coefficients of X.

M >	DGinfo(X, "CoefficientList", "all");

$[a, b, b]$

(2.4)

Find the coefficients of D_x and D_y in X (Method 1).

M >	DGinfo(X, "CoefficientList", [[1], [2]]);

$[a, b]$

(2.5)

Find the coefficients of D_x and D_y in X (Method 2).

M >	DGinfo(X, "CoefficientList", [D_x, D_y]);

$[a, b]$

(2.6)

Define a type (1,1) tensor T.

M >	T := evalDG(adx &t D_x + bdy &t D_z + c*dz &t D_x);

$T := a dx D_x + b dy D_z + c dz D_x$

(2.7)

Find the coefficient of dx D_x in T.

M >	DGinfo(T, "CoefficientList", [[1, 1]]);

$[a]$

(2.8)

Find the coefficients of dy D_z and dz D_z in T.

M >	DGinfo(alpha, "CoefficientList", [dy &tensor D_z, dz &tensor D_z]);

$[α]$

(2.9)

GetComponents

The command GetComponents provides a very useful set of procedures for determining if a given VFT or list of VFT can be expressed as a linear combination of a set of VFT.

M >	with(DifferentialGeometry): with(Tools):

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

Example 1. Express the vector X as a linear combination of the vectors in the list B. Check the result with DGzip.

M >	X := evalDG(2*D_x + D_y - D_z);

$X := 2 D_x + D_y - D_z$

(3.1)

M >	B := evalDG([D_x - D_y, D_y - D_z, D_z + D_x]);

$B := [D_x - D_y, D_y - D_z, D_x + D_z]$

(3.2)

M >	C := GetComponents(X, B);

$C := [1, 2, 1]$

(3.3)

M >	DGzip(C, B, "plus");

$2 D_x + D_y - D_z$

(3.4)

Example 2. GetComponents returns an empty list if the VFT is not a linear combination of the given list of VFT. For example, the 2-form alpha is not a linear combination of the 2-forms in the list S.

M >	alpha := dy &wedge dz;

$α := dy ⋀ dz$

(3.5)

M >	S := [dx &wedge dy, dx &wedge dz];

$S := [dx ⋀ dy, dx ⋀ dz]$

(3.6)

M >	GetComponents(alpha, S);

$[]$

(3.7)

Example 3. The first argument to GetComponents can also be a list of VFTs, in which case the list of lists of components is returned. In this example, we find all the components C of all the vectors in the basis A as linear combinations of the vectors in the basis B. We find the change of basis Matrix P relating the two bases A and B.

M >	A := evalDG([D_x + D_y + 2D_z, D_y + D_z, 2D_z]);

$A := [D_x + D_y + 2 D_z, D_y + D_z, 2 D_z]$

(3.8)

M >	B := evalDG([D_x - D_y, D_y - D_z, D_z + D_x]);

$B := [D_x - D_y, D_y - D_z, D_x + D_z]$

(3.9)

M >	C := GetComponents(A, B);

$C := [[- 1, 0, 2], [- 1, 0, 1], [- 1, - 1, 1]]$

(3.10)

M >	P := LinearAlgebra[Transpose](Matrix(C));

Example 4. With the optional argument method = "real", the GetComponents command will determine if the linear combination can be found with real numbers as coefficients -- (no functions allowed). Compare the results of the following commands.

M >	GetComponents(x &mult D_x, [D_x]);

$[x]$

(3.11)

M >	GetComponents(x &mult D_x, [D_x], method = "real");

$[]$

(3.12)

M >	GetComponents(x &mult D_x, [D_x, x &mult D_x, (x^2) &mult D_x], method = "real");

$[0, 1, 0]$

(3.13)

GenerateForms, GenerateTensors, GenerateSymmetricTensors

The utilities GenerateForms, GenerateTensors, GenerateSymmetricTensors are used to generate bases for different spaces of differential forms and tensors.

M >	with(DifferentialGeometry): with(Tools): with(Tensor):

M >	DGsetup([u, v, w, x, y], E5);

$frame name: E5$

(4.1)

Example 1. Define a list Omega of four 1-forms.

E5 >	Omega := [du, dv, dw, dx];

$Ω := [du, dv, dw, dx]$

(4.2)

Find a basis for the space of all 2-forms generated by Omega.

E5 >	GenerateForms(Omega, 2);

$[du ⋀ dv, du ⋀ dw, du ⋀ dx, dv ⋀ dw, dv ⋀ dx, dw ⋀ dx]$

(4.3)

Find a basis for the space of all 4-forms generated by Omega.

E5 >	GenerateForms(Omega, 4);

$[du ⋀ dv ⋀ dw ⋀ dx]$

(4.4)

Example 2. Find a basis for the space of all rank 3 tensors whose first components are taken from the list S1, whose second components come from S2 and whose third components come from S3.

E5 >	S1 := [D_x, D_y];

$S1 := [D_x, D_y]$

(4.5)

E5 >	S2 := [du, dv];

$S2 := [du, dv]$

(4.6)

E5 >	S3 := [dw, dx];

$S3 := [dw, dx]$

(4.7)

E5 >	GenerateTensors([S1, S2, S3]);

$[D_x du dw, D_x du dx, D_x dv dw, D_x dv dx, D_y du dw, D_y du dx, D_y dv dw, D_y dv dx]$

(4.8)

Example 3. Find a basis for the space of all rank 2 symmetric tensors generated by Omega.

E5 >	GenerateSymmetricTensors(Omega, 2);

$[du du, \frac{1}{2} du dv + \frac{1}{2} dv du, \frac{1}{2} du dw + \frac{1}{2} dw du, \frac{1}{2} du dx + \frac{1}{2} dx du, dv dv, \frac{1}{2} dv dw + \frac{1}{2} dw dv, \frac{1}{2} dv dx + \frac{1}{2} dx dv, dw dw, \frac{1}{2} dw dx + \frac{1}{2} dx dw, dx dx]$

(4.9)

DGbasis

The utility DGbasis will select a maximal collection of independent VFT from a list of VFT. With method = "real", the program finds a maximal collection of independent VFT over the real numbers, otherwise independence is taken with respect to the ring of functions on the manifold.

E5 >	with(DifferentialGeometry):

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

Example 1. The 2nd and 3rd vectors in S1 define a basis for the subspace spanned by the vectors in the list S1.

E3 >	S1 := evalDG([D_x, 2*D_x, D_x - D_y, D_y]);

$S1 := [D_x, 2 D_x, D_x - D_y, D_y]$

(5.1)

E3 >	DGbasis(S1);

$[D_x, D_x - D_y]$

(5.2)

Example 2. Over the ring of functions, the 2nd and 3rd vectors in the list S2 are linearly dependent on the 1st vector. Over the real numbers, the vectors in S2 are linearly independent.

E3 >	S2 := evalDG([D_x, xD_x, x^2D_x]);

$S2 := [D_x, x D_x, x^{2} D_x]$

(5.3)

E3 >	DGbasis(S2);

$[D_x]$

(5.4)

E3 >	DGbasis(S2, method = "real");

$[D_x, x D_x, x^{2} D_x]$

(5.5)

ComplementaryBasis

Let S1 be a subspace of S2 (a vector space of vectors, differential forms, or tensors) with basis B1 and B2 respectively. The command ComplementaryBasis calculates a complementary subspace C to S1 in S2, that is, S1 + C = S2 (direct sum). The vectors defining the basis for C are chosen from B2.

E3 >	with(DifferentialGeometry):

E3 >	DGsetup([x, y, z, w], E4):

Example 1. To extend the set of basis vectors B1 to a basis for the span of B2, we need to include the vector D_w.

E4 >	B1 := evalDG([D_x, D_y]);

$B1 := [D_x, D_y]$

(6.1)

E4 >	B2 := [D_x, D_y, D_w];

$B2 := [D_x, D_y, D_w]$

(6.2)

E4 >	ComplementaryBasis(B1, B2);

$[D_w]$

(6.3)

Example 2. We calculate a complement to the subspace of 2-forms spanned by B1 in the space of all 2-forms on E4.

E4 >	B1 := [dx &wedge dy, dx &wedge dz, dx &wedge dw];

$B1 := [dx ⋀ dy, dx ⋀ dz, dx ⋀ dw]$

(6.4)

E4 >	Omega := Tools:-DGinfo("FrameBaseForms");

$Ω := [dx, dy, dz, dw]$

(6.5)

E4 >	B2 := Tools:-GenerateForms(Omega, 2);

$B2 := [dx ⋀ dy, dx ⋀ dz, dx ⋀ dw, dy ⋀ dz, dy ⋀ dw, dz ⋀ dw]$

(6.6)

E4 >	ComplementaryBasis(B1, B2);

$[dy ⋀ dz, dy ⋀ dw, dz ⋀ dw]$

(6.7)

DualBasis

If X[i], i = 1 ... n is a basis for a vector space V, then the dual basis for the dual space V^* consists of the 1-forms theta[j], j = 1 ... n, satisfying theta[j](X[i]) = delta[i, j], where delta[i, j] is the Kronecker delta.

E4 >	with(DifferentialGeometry):

E4 >	DGsetup([x, y, z], E3):

Example 1. The vectors in the list B define a basis for the tangent space to E3 at each point.

E3 >	B := evalDG([D_x + D_y + D_z, D_y + D_z, D_z]);

$B := [D_x + D_y + D_z, D_y + D_z, D_z]$

(7.1)

Calculate the basis Theta for the cotangent space which is dual to B.

E3 >	Theta := DualBasis(B);

$Θ := [dx, - dx + dy, - dy + dz]$

(7.2)

Let us check this result using the procedure Hook.

E3 >	Matrix(3, 3, (i, j) -> Hook(B[i], Theta[j]));

Example 2. The command DualBasis can also be applied to a list of 1-forms. In this example, the dual basis to the 1-forms Theta are the vectors B we started with in Example 1.

E3 >	DualBasis(Theta);

$[D_x + D_y + D_z, D_y + D_z, D_z]$

(7.3)

Annihilator

Let A be a set of vectors in a vector space V. Then the annihilating space B is the subspace of covectors alpha in the dual space V^* such that alpha(X) = 0 for all X in A. The dimension of B is dim(B) = dim(V) - dim(span(A)).

E3 >	with(DifferentialGeometry):

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

Example 1. Find the annihilating subspace B to the set of vectors A and check the result.

M >	A := [D_x, D_y];

$A := [D_x, D_y]$

(8.1)

M >	B := Annihilator(A);

$B := [dv, du, dz]$

(8.2)

M >	Matrix(2, 3, (i, j) -> Hook(A[i], B[j]));

Example 2. Find the annihilating subspace B to the set of 1-forms A.

M >	A := evalDG([dx + dy, dy - du]);

$A := [dx + dy, dy - du]$

(8.3)

M >	B := Annihilator(A);

$B := [D_v, - D_x + D_y + D_u, D_z]$

(8.4)

M >	Matrix(3, 2, (i, j) -> Hook(B[i], A[j]));

Exercises

Exercise 1

For what values of the parameter a are the differential 1-forms in the set S linearly independent?

Hint: A list of 1-forms are independent if and only if the their wedge product is non-zero.

M >	with(DifferentialGeometry):

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

M >	S := evalDG([dx + ady, dx - ady + dz, dx + dy - a*dz]);

$S := [dx + a dy, dx - a dy + dz, dx + dy - a dz]$

(9.1.1)

Solution

Compute the wedge product of the forms in S (Method 1).

M >	Omega := S[1] &wedge S[2] &wedge S[3];

$Ω := (a - 1 + 2 a^{2}) dx ⋀ dy ⋀ dz$

(9.1.1.1)

Compute the wedge product of the forms in S (Method 2).

M >	Omega := DGzip(S, "wedge");

$Ω := (a - 1 + 2 a^{2}) dx ⋀ dy ⋀ dz$

(9.1.1.2)

Get the coefficient of Omega, set it to zero, and solve for a.

M >	Eq := Tools:-DGinfo(Omega, "CoefficientSet");

$Eq := \{a - 1 + 2 a^{2}\}$

(9.1.1.3)

M >	solve(Eq, {a});

$\{a = \frac{1}{2}\}, \{a = - 1\}$

(9.1.1.4)

The 3 1-forms in the set S are linearly independent except when a = 1/2 and a = -1.

Exercise 2

Write a program ChangeCoefficient that will change the value of a prescribed coefficient in a vector, differential form, or tensor. Take as input for the program a VFT, a "monomial" VFT representing the term in the VFT that is to be changed, and the new value of the coefficient. Use your program to change the coefficient of dx^dz in Omega from 2 to K.

M >	with(DifferentialGeometry):

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

M >	Omega := evalDG(dx &w dy + 2dx &w dz + 3dy &w dz);

$Ω := dx ⋀ dy + 2 dx ⋀ dz + 3 dy ⋀ dz$

(9.2.1)

Solution

M >	ChangeCoefficient := proc(X, T, a)

M >

local b;

M >	b := DifferentialGeometry:-Tools:-DGinfo(X, "CoefficientList", [T])[1];

M >	X &plus ((a - b) &mult T);

M >

end:

Example 1. Change the coefficient of dx^dz in Omega from 2 to K.

M >	Omega := evalDG(dx &w dy + 2dx &w dz + 3dy &w dz);

M >	ChangeCoefficient(Omega, dx &wedge dz, K);

$Ω := dx ⋀ dy + 2 dx ⋀ dz + 3 dy ⋀ dz$

$dx ⋀ dy + K dx ⋀ dz + 3 dy ⋀ dz$

(9.2.1.1)

Example 2. Change the coefficient of dx dx D_y in T from 1 to 4.

M >	T := evalDG(dx &t dy &t D_z + 2dx &t dz &t D_x + 3dy &t dz &t D_y);

$T := dx dy D_z + 2 dx dz D_x + 3 dy dz D_y$

(9.2.1.2)

M >	ChangeCoefficient(T, dx &t dx &t D_y, 4);

$4 dx dx D_y + dx dy D_z + 2 dx dz D_x + 3 dy dz D_y$

(9.2.1.3)

Exercise 3

M >	with(DifferentialGeometry):

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

[i] Express the vector field X as a linear combination of the vector fields B1. Check your result using DGzip.

M >	X := evalDG(D_x + 3*D_y - D_z);

$X := D_x + 3 D_y - D_z$

(9.3.1)

M >	B1 := evalDG([D_x - 2D_y, D_y + D_z, D_x - D_y + 2D_z]);

$B1 := [D_x - 2 D_y, D_y + D_z, D_x - D_y + 2 D_z]$

(9.3.2)

[ii] Express the differential 2-form alpha as a linear combination of the 2-forms B2. Check your result using DGzip.

M >	alpha := evalDG(2*dx &w dy);

$α := 2 dx ⋀ dy$

(9.3.3)

M >	B2 := evalDG([dx &w dy + dz &w dw, dx &w dz + dy &w dw, dx &w dw + dy &w dz, dx &w dy + dx &w dz, dx &w dz + dy &w dz, dy &w dz + dy &w dw]);

$B2 := [dx ⋀ dy + dz ⋀ dw, dx ⋀ dz + dy ⋀ dw, dx ⋀ dw + dy ⋀ dz, dx ⋀ dy + dx ⋀ dz, dx ⋀ dz + dy ⋀ dz, dy ⋀ dz + dy ⋀ dw]$

(9.3.4)

[iii] Express the rank 3 tensor T as a linear combination of the tensors B3. Check your result using DGzip.

M >	T := evalDG(dx &t D_y &t D_z - dx &t D_z &t D_x + 2dy &t D_z &t D_z - 2dz &t D_z &t D_y);

$T := dx D_y D_z - dx D_z D_x + 2 dy D_z D_z - 2 dz D_z D_y$

(9.3.5)

M >	B3 := evalDG([dx &t D_y &t D_z - dz &t D_z &t D_y, dx &t D_z &t D_x + dz &t D_z &t D_y, dy &t D_z &t D_z]);

$B3 := [dx D_y D_z - dz D_z D_y, dx D_z D_x + dz D_z D_y, dy D_z D_z]$

(9.3.6)

Solution

[i] Express the vector field X as a linear combination of the vector fields B1. Check your result using DGzip.

M >	C1 := GetComponents(X, B1);

$C1 := [7, 11, - 6]$

(9.3.1.1)

M >	X &minus DGzip(C1, B1, "plus");

$0 D_x$

(9.3.1.2)

[ii] Express the differential 2-form alpha as a linear combination of the 2-forms B2. Check your result using DGzip.

M >	C2 := GetComponents(alpha, B2);

$C2 := [0, - 1, 0, 2, - 1, 1]$

(9.3.1.3)

M >	alpha &minus DGzip(C2, B2, "plus");

$0 dx ⋀ dy$

(9.3.1.4)

[iii] Express the rank 3 tensor T as a linear combination of the tensors B3. Check your result using DGzip.

M >	C3 := GetComponents(T, B3);

$C3 := [1, - 1, 2]$

(9.3.1.5)

M >	T &minus DGzip(C3, B3, "plus");

$0 dx D_x D_x$

(9.3.1.6)

Exercise 4

Show that the vector X is a linear combination of the vectors with variable coefficients but not with constant coefficients.

M >	with(DifferentialGeometry):

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

M >

X := D_z;

$X := D_z$

(9.4.1)

M >	B := evalDG([xD_x + yD_y + zD_z, xD_y - yD_x, xD_z - zD_x, zD_y - y*D_z]);

$B := [x D_x + y D_y + z D_z, - y D_x + x D_y, - z D_x + x D_z, z D_y - y D_z]$

(9.4.2)

Solution

M >	GetComponents(X, B);

$[\frac{z}{x^{2} + y^{2} + z^{2}}, - \frac{({_t15}_{1, 1} x^{2} + y^{2} {_t15}_{1, 1} + y + {_t15}_{1, 1} z^{2}) z}{x (x^{2} + y^{2} + z^{2})}, \frac{x^{2} + y^{2} + y {_t15}_{1, 1} x^{2} + y^{3} {_t15}_{1, 1} + y {_t15}_{1, 1} z^{2}}{x (x^{2} + y^{2} + z^{2})}, {_t15}_{1, 1}]$

(9.4.1.1)

The presence of the parameter _t[1, 1] indicates that the vectors in B are not linearly independent and that X can be expressed in terms of the vectors in B in infinitely many ways.

To see if X is a constant coefficient linear combination of the vectors in B, use GetComponents with the option method = "real".

M >	GetComponents(X, B, method = "real");

$[]$

(9.4.1.2)

Exercise 5

Extend the set of 1 forms S to a basis for the cotangent space of M.

M >	with(DifferentialGeometry):

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

M >	S := evalDG([dx - dy + dz, dy + dw]);

$S := [dx - dy + dz, dy + dw]$

(9.5.1)

Solution

Use the ComplementaryBasis command with the standard basis for the cotangent space as the second argument.

M >	C := ComplementaryBasis(S, [dx, dy, dz, dw]);

$C := [dx, dy]$

(9.5.1.1)

The 1-forms S and C together form a basis for the cotangent space of M.

Exercise 6

Find a maximally independent set of VFT from each of the following lists of VFT.

M >	with(DifferentialGeometry):

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

[i]

M >	B1 := evalDG([ D_x, D_y, D_z, D_z, D_y, D_w]);

$B1 := [D_x, D_y, D_z, D_z, D_y, D_w]$

(9.6.1)

[ii]

M >	B2 := evalDG([D_x &t dx, D_y &t dy, D_x &t dx + D_y &t dy, D_y &t dx]);

$B2 := [D_x dx, D_y dy, D_x dx + D_y dy, D_y dx]$

(9.6.2)

[iii] Most of the linear algebra utilities in DifferentialGeometry also work with Vectors and Matrices.

M >	B3 := [Matrix([[1, 0], [0, 1]]), Matrix([[1, 2], [0, 1]]), Matrix([[1, 1], [0, 1]]), Matrix([[1, -1], [0, -1]])];

Solution

Part [i]

M >	B1, DGbasis(B1);

$[D_x, D_y, D_z, D_z, D_y, D_w], [D_x, D_y, D_z, D_w]$

(9.6.1.1)

Part[ii]

M >	B2, DGbasis(B2);

$[D_x dx, D_y dy, D_x dx + D_y dy, D_y dx], [D_x dx, D_y dy, D_y dx]$

(9.6.1.2)

Part[iii]

M >	B3, DGbasis(B3);

Exercise 7

Show that the vectors in the list B are linearly independent over the real numbers but not over the ring of real-valued functions on M.

M >	with(DifferentialGeometry):

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

M >	B := evalDG([D_x, D_y, xD_x, yD_x, xD_y, yD_y]);

$B := [D_x, D_y, x D_x, y D_x, x D_y, y D_y]$

(9.7.1)

Solution

Note that there are 6 vectors in the list B.

M >

nops(B);

$6$

(9.7.1.1)

We apply the DGbasis procedure with the option method = "real".

M >	C1 := DGbasis(B, method = "real");

$C1 := [D_x, D_y, x D_x, y D_x, x D_y, y D_y]$

(9.7.1.2)

M >

nops(C1);

$6$

(9.7.1.3)

Since the number of vectors in B equals the number of vectors in C1, the vectors in B must be independent over the real numbers.

However, over the ring of functions, there are only two independent vectors.

M >	C2 := DGbasis(B);

$C2 := [D_x, D_y]$

(9.7.1.4)

Exercise 8

a) Generate a basis of all 3-forms for the manifold N with coordinates z1, z2, z3, z4, z5.

b) Generate all symmetric rank 4 contravariant tensors for the manifold P with coordinates u, v.

c) Generate all type (2, 1) tensors (covariant rank 2, contravariant rank 1) which are skew-symmetric in the first two arguments for the manifold Q with coordinates x, y, z.

Solution

M >	with(DifferentialGeometry): with(Tools): DGsetup([z1, z2, z3, z4, z5], "N"):

N >	Omega := DGinfo("FrameBaseForms");

$Ω := [dz1, dz2, dz3, dz4, dz5]$

(9.8.1.1)

N >	GenerateForms(Omega, 3);

$[dz1 ⋀ dz2 ⋀ dz3, dz1 ⋀ dz2 ⋀ dz4, dz1 ⋀ dz2 ⋀ dz5, dz1 ⋀ dz3 ⋀ dz4, dz1 ⋀ dz3 ⋀ dz5, dz1 ⋀ dz4 ⋀ dz5, dz2 ⋀ dz3 ⋀ dz4, dz2 ⋀ dz3 ⋀ dz5, dz2 ⋀ dz4 ⋀ dz5, dz3 ⋀ dz4 ⋀ dz5]$

(9.8.1.2)

N >	with(DifferentialGeometry): with(Tensor): DGsetup([u, v], "P"):

P >	GenerateSymmetricTensors([D_u, D_v], 4);

$[D_u D_u D_u D_u, \frac{1}{4} D_u D_u D_u D_v + \frac{1}{4} D_u D_u D_v D_u + \frac{1}{4} D_u D_v D_u D_u + \frac{1}{4} D_v D_u D_u D_u, \frac{1}{6} D_u D_u D_v D_v + \frac{1}{6} D_u D_v D_u D_v + \frac{1}{6} D_u D_v D_v D_u + \frac{1}{6} D_v D_u D_u D_v + \frac{1}{6} D_v D_u D_v D_u + \frac{1}{6} D_v D_v D_u D_u, \frac{1}{4} D_u D_v D_v D_v + \frac{1}{4} D_v D_u D_v D_v + \frac{1}{4} D_v D_v D_u D_v + \frac{1}{4} D_v D_v D_v D_u, D_v D_v D_v D_v]$

(9.8.1.3)

P >	with(DifferentialGeometry): with(Tensor): DGsetup([x, y, z], "Q"):

P >	T1 := GenerateSymmetricTensors([dx, dy, dz], 2);

$T1 := [dx dx, \frac{1}{2} dx dy + \frac{1}{2} dy dx, \frac{1}{2} dx dz + \frac{1}{2} dz dx, dy dy, \frac{1}{2} dy dz + \frac{1}{2} dz dy, dz dz]$

(9.8.1.4)

Q >	T2 := [D_x, D_y, D_z];

$T2 := [D_x, D_y, D_z]$

(9.8.1.5)

Q >	GenerateTensors([T1, T2]);

$[dx dx D_x, dx dx D_y, dx dx D_z, \frac{1}{2} dx dy D_x + \frac{1}{2} dy dx D_x, \frac{1}{2} dx dy D_y + \frac{1}{2} dy dx D_y, \frac{1}{2} dx dy D_z + \frac{1}{2} dy dx D_z, \frac{1}{2} dx dz D_x + \frac{1}{2} dz dx D_x, \frac{1}{2} dx dz D_y + \frac{1}{2} dz dx D_y, \frac{1}{2} dx dz D_z + \frac{1}{2} dz dx D_z, dy dy D_x, dy dy D_y, dy dy D_z, \frac{1}{2} dy dz D_x + \frac{1}{2} dz dy D_x, \frac{1}{2} dy dz D_y + \frac{1}{2} dz dy D_y, \frac{1}{2} dy dz D_z + \frac{1}{2} dz dy D_z, dz dz D_x, dz dz D_y, dz dz D_z]$

(9.8.1.6)

Exercise 9

Find a complementary basis in the space of rank 3 contravariant tensors to the space of symmetric rank 3 contravariant tensors for the manifold P with coordinates u, v.

Q >	with(DifferentialGeometry):

Q >	with(Tensor):

Q >	DGsetup([u, v], Q):

Solution

Q >	Omega := [du, dv]:

Use the GenerateSymmetricTensors command to find a basis for the rank 3 symmetric covariant tensors.

Q >	T1 := GenerateSymmetricTensors(Omega, 3);

$T1 := [du du du, \frac{1}{3} du du dv + \frac{1}{3} du dv du + \frac{1}{3} dv du du, \frac{1}{3} du dv dv + \frac{1}{3} dv du dv + \frac{1}{3} dv dv du, dv dv dv]$

(9.9.1.1)

Use the GenerateTensors command to find a basis for the rank 3 covariant tensors.

Q >	T2 := GenerateTensors([Omega, Omega, Omega]);

$T2 := [du du du, du du dv, du dv du, du dv dv, dv du du, dv du dv, dv dv du, dv dv dv]$

(9.9.1.2)

Q >	Answer := ComplementaryBasis(T1, T2);

$Answer := [du du dv, du dv du, du dv dv, dv du dv]$

(9.9.1.3)

Exercise 10

Find the dual basis for each of the following. Check your result.

Q >	with(DifferentialGeometry):

Q >	DGsetup([x, y, u, v], M):

[i]

M >	A := evalDG([D_x + D_y + D_u + D_v, D_y + D_u + D_v, D_u + D_v, D_v]);

$A := [D_x + D_y + D_u + D_v, D_y + D_u + D_v, D_u + D_v, D_v]$

(9.10.1)

[ii]

M >	B := evalDG([dx + dy, dy + du, du + dv, dv - dx]);

$B := [dx + dy, dy + du, du + dv, - dx + dv]$

(9.10.2)

Solution

Part [i]

M >	Answer1 := DualBasis(A);

$Answer1 := [dx, - dx + dy, - dy + du, - du + dv]$

(9.10.1.1)

M >	Matrix(4, 4, (i, j) -> Hook(A[i], Answer1[j]));

Part [ii]

M >	Answer2 := DualBasis(B);

$Answer2 := [\frac{1}{2} D_x + \frac{1}{2} D_y - \frac{1}{2} D_u + \frac{1}{2} D_v, - \frac{1}{2} D_x + \frac{1}{2} D_y + \frac{1}{2} D_u - \frac{1}{2} D_v, \frac{1}{2} D_x - \frac{1}{2} D_y + \frac{1}{2} D_u + \frac{1}{2} D_v, - \frac{1}{2} D_x + \frac{1}{2} D_y - \frac{1}{2} D_u + \frac{1}{2} D_v]$

(9.10.1.2)

M >	Matrix(4, 4, (i, j) -> Hook(Answer2[i], B[j]));

Exercise 11

Write a program TestIndependence (without using DGbasis) that will return true if a given list of VFT are linearly independent and false otherwise.

This exercise introduces some important coding techniques which are used repeatedly in the DifferentialGeometry procedures and which are often needed to create new applications.

Hint: Use DGzip to form a VFT X from the given list with unknown coefficients. Extract the coefficients of X to obtain a set of equations Eq. Use LinearAlgebra:-GenerateMatrix to obtain the coefficient matrix A for the system of linear equations defined by Eq. Use LinearAlgebra:-Rank to calculate the rank of the matrix A.

Test you program on the list of vectors B1 and the list of 2-forms B2.

M >	with(DifferentialGeometry):

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

$frame name: M$

(9.11.1)

M >	B1 := evalDG([D_x - D_y, D_y + D_z, D_x - 2D_y + 3D_z]);

$B1 := [D_x - D_y, D_y + D_z, D_x - 2 D_y + 3 D_z]$

(9.11.2)

M >	B2 := evalDG([dx &w dy, dx &w dz, dx &w dy + dz &w dx]);

$B2 := [dx ⋀ dy, dx ⋀ dz, dx ⋀ dy - dx ⋀ dz]$

(9.11.3)

Solution

M >	TestIndependence := proc(VFTlist)

M >	local A, X, n, vars, Eq, r, answer;

M >	n := nops(VFTlist);

M >	vars := [seq(_a\|\|i, i = 1 .. n)];

M >	X := DGzip(vars, VFTlist, "plus");

M >	Eq := Tools:-DGinfo(X, "CoefficientSet");

M >	A := LinearAlgebra:-GenerateMatrix(Eq, vars)[1];

M >	r := LinearAlgebra:-Rank(A);

M >	if r < n then answer := false else answer := true fi;

M >

answer;

M >

end:

M >

>	TestIndependence(B1);

$true$

(9.11.1.1)

M >	TestIndependence(B2);

$false$

(9.11.1.2)

To watch the program at work, use the Maple debug command.

M >	debug(TestIndependence);

$TestIndependence$

(9.11.1.3)

M >	TestIndependence(B1);

{--> enter TestIndependence, args = [_DG([[vector, M, []], [[[1], 1], [[2], -1]]]), _DG([[vector, M, []], [[[2], 1], [[3], 1]]]), _DG([[vector, M, []], [[[1], 1], [[2], -2], [[3], 3]]])]

$n := 3$

$vars := [_a1,_a2,_a3]$

$X := (_a3 +_a1) D_x - (2_a3 -_a2 +_a1) D_y + (3_a3 +_a2) D_z$

$Eq := \{_a3 +_a1, 3_a3 +_a2, - 2_a3 +_a2 -_a1\}$

$r := 3$

$answer := true$

$true$

<-- exit TestIndependence (now at top level) = true}

$true$

(9.11.1.4)

There is one change in the program that should be made -- there is no assurance that the variables _a1, _a2, _a3 are not defined by the user, in which case, the program will not work. We can avoid this problem by using a little utility program from the Maple tools package. This program is guaranteed to generate a sequence of unassigned names.

M >	`tools/_Qn`(p,[],4);

$p1, p2, p3, p4$

(9.11.1.5)

M >	p1 := 3: p5 := 0:

M >	`tools/_Qn`(p,[],4);

$p2, p3, p4, p6$

(9.11.1.6)

Therefore the line vars := [seq(_a||i, i = 1 .. n)]; should be replaced by vars := [`tools/_Qn`(_a, [], n)].

Exercise 12

A p-form omega is called decomposable if it is the wedge product of p 1-forms. If we define A = {X : Hook(X, omega) = 0}, then it is not difficult to prove that omega is decomposable if and only if dim(A) = n - p, where n is the dimension of the ambient manifold. The space A is called the retracting space for omega. Moreover, if omega is decomposable, then it is a multiple of the wedge product of the 1-forms in Annihilator(A). (See Hook, Annihilator)

[i] Write a program RetractingSpace that will compute the retracting space for a p-form omega.

Hint: Follow Example 11 and use LinearAlgebra:-NullSpace.

[ii] Write a program DecomposeForm that will determine if a p-form is decomposable and, if so, return a list of p 1-forms whose wedge product is the given p-form. If the form is not decomposable return an empty list.

Test your programs on the forms alpha, beta, theta.

M >	with(DifferentialGeometry):

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

M >	alpha := dx &wedge dy &wedge dz;

$α := dx ⋀ dy ⋀ dz$

(9.12.1)

M >	beta := evalDG(dx &w dy + du &w dv);

$β := dx ⋀ dy + du ⋀ dv$

(9.12.2)

M >	theta := evalDG(9dx &w dy &w du - 13dx &w dy &w dv + 5dx &w du &w dv + 2dy &w du &w dv);

$θ := 9 dx ⋀ dy ⋀ du - 13 dx ⋀ dy ⋀ dv + 5 dx ⋀ du ⋀ dv + 2 dy ⋀ du ⋀ dv$

(9.12.3)

Solution

M >	RetractingSpace := proc(omega0)

M >	local omega, A, X, n, vars, alpha, Eq, B, N, p, C, c, i;

M >	omega := evalDG(omega0);

M >	A := Tools:-DGinfo("FrameBaseVectors");

M >	n := Tools:-DGinfo("FrameBaseDimension");

M >	vars := [`tools/_Qn`(_a,[],n)];

M >	X := DGzip(vars, A,"plus");

M >	alpha := Hook(X, omega);

M >	Eq := Tools:-DGinfo(alpha, "CoefficientSet");

M >	B := LinearAlgebra:-GenerateMatrix(Eq, vars)[1];

M >	N := LinearAlgebra:-NullSpace(B);

M >	p := nops(N);

M >	C := Array(1 .. p);

M >	for i to p do

M >	c := convert(N[i], list);

M >	C[i] := DGzip(c, A, "plus");

M >

od;

M >	convert(C, list);

M >

end:

M >

M >	DecomposeForm := proc(omega0)

M >	local A, omega, n, p, q, B, C, alpha, Eq, soln, newC1, k;

M >	omega := evalDG(omega0);

M >	n := Tools:-DGinfo("FrameBaseDimension");

M >	p := Tools:-DGinfo(omega, "FormDegree");

M >	A := RetractingSpace(omega);

M >	q := nops(A);

M >	if q <> n - p then return [] fi;

M >	B := Tools:-DGinfo("FrameBaseForms");

M >	C := Annihilator(A, B);

M >	alpha := k &mult DGzip(C, "wedge");

M >	Eq := Tools:-DGinfo(omega0 &minus alpha, "CoefficientSet");

M >	soln:= solve(Eq, {k});

M >	newC1 := eval(k &mult C[1], soln);

M >	[newC1, op(C[2 .. -1])];

end:

Example 1.

M >

alpha;

$dx ⋀ dy ⋀ dz$

(9.12.1.1)

M >	RetractingSpace(alpha);

$[D_v, D_u]$

(9.12.1.2)

M >	DecomposeForm(alpha);

$[- dy, dx, dz]$

(9.12.1.3)

Example 2.

M >

beta;

$dx ⋀ dy + du ⋀ dv$

(9.12.1.4)

M >	RetractingSpace(beta);

$[D_z]$

(9.12.1.5)

M >	DecomposeForm(beta);

$[]$	(9.12.1.6)

Example 3.

M >

theta;

$9 dx ⋀ dy ⋀ du - 13 dx ⋀ dy ⋀ dv + 5 dx ⋀ du ⋀ dv + 2 dy ⋀ du ⋀ dv$

(9.12.1.7)

M >	RetractingSpace(theta);

$[- \frac{2}{9} D_x + \frac{5}{9} D_y + \frac{13}{9} D_u + D_v, D_z]$

(9.12.1.8)

M >	F := DecomposeForm(theta);

$F := [- 9 dx - 2 dv, \frac{13}{2} dx + du, \frac{5}{2} dx + dy]$

(9.12.1.9)

M >	theta &minus DGzip(F, "wedge");

$0 dx ⋀ dy ⋀ dz$

(9.12.1.10)

M >

Download Help Document

Maple

Maple Add-Ons

MapleSim

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim

Maple

Powerful math software that is easy to use

Maple Add-Ons

MapleSim

Advanced System Level Modeling

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim