Lesson 7: The Pushforward of a Vector - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim


DifferentialGeometry Lessons

 

Lesson 7: The Pushforward of a Vector by a Transformation

 

 

Overview

Pushforward 1 - definitions

Pushforward 2

PullbackVector

Application: The definition of the Lie bracket in terms of flows

Application: The straightening theorem for vectors fields and systems of commuting vector fields

Exercises

Overview

 

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

– 

Pushforward a vector pointwise.

– 

Pushforward a vector field under a diffeomorphism.

– 

Check the definition of Lie bracket in terms of flows.

– 

Apply the straightening theorem for vector fields and systems of commuting vector fields.

 

Pushforward 1 - definitions

 

Recall that if phi : M ->N, then the pushforward map is the linear transformation between tangent spaces phi_* : T_pM -> T_qN, where q = phi(p).  In general,  the map phi_* can only be applied to a vector at a given point ; only in special situations, it can be applied to a vector field on M to obtain a vector field on N.

 

In this section, we shall illustrate three methods for computing the pushforward phi_*(X):

– 

from the Jacobian matrix of phi.

– 

using a curve tangent to the vector X.

– 

using the definition of phi_* in terms of  its action on the space of derivations.

>

with(DifferentialGeometry):

DGsetup([x, y], M2):

M2 > 

DGsetup([u, v], N):

DGsetup([x, y, z], M3):

N > 

DGsetup([u, v], N):

 

Define a transformation phi from N to M3.

N > 

phi := Transformation(N, M3, [x = 2*u/(1 + u^2 + v^2), y = 2*v/(1 + u^2 + v^2), z = (u^2 + v^2 - 1)/(1 + u^2 + v^2)]);

φx=2u1+u2+v2,y=2v1+u2+v2,z=u2+v211+u2+v2

(2.1)

 

The map phi defines stereographic coordinates on the 2-sphere x^2 + y^2 + z^2 = 1.  We check this by noting that  the image of phi lies on the sphere.

N > 

P := ApplyTransformation(phi, [u, v]);

P2u1+u2+v2,2v1+u2+v2,u2+v211+u2+v2

(2.2)
M3 > 

simplify(P[1]^2 + P[2]^2 + P[3]^2);

1

(2.3)

 

Define a vector X in the uv-plane at the point [u =1, v=2] and push it forward to a vector Y1 on the sphere.

M3 > 

X := evalDG(a*D_u + b*D_v);

XaD_u+bD_v

(2.4)
N > 

Y1 := Pushforward(phi, X, [u = 1, v = 2]);

Y12b9+2a9D_x+b92a9D_y+2b9+a9D_z

(2.5)

The vector Y1 is a tangent vector to the sphere at the point [1/3, 2/3, 2/3].

 

We recall that the pushforward can be computed from the matrix product of the Jacobian of phi with the components of the vector X.  To check this, we find the Jacobian of Phi at the point [u =1, v=2].

M3 > 

J := Tools:-DGinfo(phi, "JacobianMatrix");

M3 > 

Jpt := eval(J, [u = 1, v = 2]);

M3 > 

B := Jpt.Vector([a, b]);

M3 > 

Z1 := DGzip(convert(B, list), [D_x, D_y, D_z], "plus");

Z12b9+2a9D_x+b92a9D_y+2b9+a9D_z

(2.6)

The vectors Y1 and Z1 coincide.

 

To pushforward the vector X at a generic point [u, v], we can use Pushforward with 2 arguments.

M3 > 

Y2 := Pushforward(phi, X);

Y222buv+aau2+av2D_x1+u2+v222bbu2+bv2+2auvD_y1+u2+v22+4bv+auD_z1+u2+v22

(2.7)

 

We can arrive at the vector Y2 using the definition of phi_* in terms of the curves.  Start with a curve sigma1 in the uv-plane whose tangent vector is X, use the map phi to map sigma1 to a curve sigma2 on the sphere, and then take the derivative of sigma2 at t = 0.  The result is the pushforward vector Y2.

M3 > 

sigma1 := Flow(X, t);

σ1u=at+u,v=bt+v

(2.8)
N > 

sigma2 := ComposeTransformations(phi, sigma1);

σ2x=2at+u1+at+u2+bt+v2,y=2bt+v1+at+u2+bt+v2,z=at+u2+bt+v211+at+u2+bt+v2

(2.9)
N > 

Z2 := InfinitesimalTransformation(sigma2, [t]);

Z222buv+aau2+av2D_x1+u2+v222bbu2+bv2+2auvD_y1+u2+v22+4bv+auD_z1+u2+v22

(2.10)
M3 > 

Y2 &minus Z2[1];

0D_x

(2.11)

 

We can also compute the components of the vector Y2 by applying the LieDerivative command to the components of the map phi.

M3 > 

P;

2u1+u2+v2,2v1+u2+v2,u2+v211+u2+v2

(2.12)
M3 > 

C := simplify(map2(LieDerivative, X, P));

C22buv+aau2+av21+u2+v22,2bbu2+bv2+2auv1+u2+v22,4bv+au1+u2+v22

(2.13)
N > 

Z3 := DGzip(C, [D_x, D_y, D_z], "plus");

Z322buv+aau2+av2D_x1+u2+v222bbu2+bv2+2auvD_y1+u2+v22+4bv+auD_z1+u2+v22

(2.14)
M3 > 

Y2 &minus Z3;

0D_x

(2.15)

 

Pushforward 2

 

Let phi : M -> N.  In this section, we examine two situations where it is possible to use phi to pushforward a vector field X on M to obtain a vector field Y on N.

 

Case 1.  If phi is a diffeomorphism (or a local diffeomorphism), then for each q in N there is a unique (locally unique) p in M such that phi(p) = q and the vector field

Y on N can be defined by Y_q = phi_*(X_p).

 

Case 2.  Let Delta be a constant rank, integrable distribution on M and let N = M/Delta, the quotient of M by the integral manifolds or leaves of Delta.  If a vector X on M preserves Delta, that is, [X, Delta] subset Delta, then there is a vector field Y on N such that pi_*(X) = Y.

 

In Case 1, the vector field Y = phi_*(X) can be computed by passing the command Pushforward the inverse of phi as a second argument.  In Case 2, pass Pushforward a (local) cross-section sigma: N -> M to the projection map pi as a second argument, that is, a map such that pi o sigma is the identity on N.

M3 > 

with(DifferentialGeometry):

M3 > 

DGsetup([x, y], M2):

M2 > 

DGsetup([x, y, z], M3):

M3 > 

DGsetup([x, y, z, w], M4):

M4 > 

DGsetup([z], M1):

M1 > 

DGsetup([u, v], N2):

 

Case 1.  Define a local diffeomorphism from M2 to N2 and a vector field X on M2.  Push the vector field X over to the vector field Y on the manifold N2.

N2 > 

phi := Transformation(M2, N2,[u = 1/2*(x^2 + y^2), v = 1/2*(x^2 - y^2)]);

φu=x22+y22,v=x22y22

(3.1)

 

We need the inverse of phi.

M2 > 

_EnvExplicit := true;

_EnvExplicittrue

(3.2)
M2 > 

psi := InverseTransformation(phi);

ψx=v+u,y=uv

(3.3)
N2 > 

ChangeFrame(M2):

M2 > 

X := evalDG((1/x)*D_x);

XD_xx

(3.4)
M2 > 

Y := Pushforward(phi, psi, X);

YD_u+D_v

(3.5)

 

Case 2.  Example 1.

N2 > 

ChangeFrame(M3):

M3 > 

Delta := [D_x, D_y];

ΔD_x,D_y

(3.6)
M3 > 

X := evalDG(z*D_x + z^2*D_z);

XzD_x+z2D_z

(3.7)

The distribution Delta is clearly integrable with 2 dimensional integral manifolds.  The global quotient is the real line with projection map pi(x, y, z) = z.

A simple choice of cross-section is sigma(z) = (0, 0, z) or more generally sigma(z) = [a, b, z], where a and b are constants.

The distribution Delta is preserved by X.

M3 > 

pi := Transformation(M3, M1, [z = z]);

πz=z

(3.8)
M3 > 

sigma := Transformation(M1, M3, [x = a, y = b, z = z]);

σx=a,y=b,z=z

(3.9)
M1 > 

Pushforward(pi, sigma, X);

z2D_z

(3.10)

 

Case 2.  Example 2.  This example is slightly more complicated.

M1 > 

ChangeFrame(M4):

M4 > 

Delta := evalDG([x*D_x + y*D_y + z*D_z + w*D_w, y*D_x - x*D_y]);

ΔxD_x+yD_y+zD_z+wD_w,yD_xxD_y

(3.11)

 

We use the LieBracket and GetComponents commands to check that Delta is a rank 2 integrable distribution.

M4 > 

GetComponents(LieBracket(Delta[1], Delta[2]), Delta);

0,0

(3.12)

 

The invariants for Delta are the functions F1 and F2 and so the projection map is pi(x, y, z, w) = (u = F1, v = F2).

M4 > 

F1 := z/sqrt(x^2 + y^2):

M4 > 

F2 := w/sqrt(x^2 + y^2):

 

Check that F1 and F2 are the invariants.

M4 > 

Matrix(2, 2, (i, j) -> simplify(LieDerivative(Delta[i], [F1, F2][j])));

 

Define the projection map.

M4 > 

pi := Transformation(M4, N2, [u = F1, v = F2]);

πu=zx2+y2,v=wx2+y2

(3.13)

 

Define the cross-section sigma and check that pi o sigma is the identity on N2.

M4 > 

sigma := Transformation(N2, M4, [x = 1, y = 0 , z = u, w = v]);

σx=1,y=0,z=u,w=v

(3.14)
N2 > 

ComposeTransformations(pi, sigma);

u=u,v=v

(3.15)

 

The following vector field preserves the distribution Delta and therefore projects under pi to a vector field on N2.

N2 > 

Z := evalDG(x*D_x + y*D_y + a*w*D_z + b*z^2*w/(x^2 + y^2)*D_w);

ZxD_x+yD_y+awD_z+bz2wD_wx2+y2

(3.16)
M4 > 

map2(LieDerivative, Z, Delta);

0D_x,0D_x

(3.17)
M4 > 

Pushforward(pi, sigma, Z);

avuD_u+vbu21D_v

(3.18)

 

PullbackVector

 

The command PullbackVector is a more specialized command.  Let phi : M -> N be a smooth map between manifolds and let Y be a vector field on N.  Suppose that for each x in M, Y_phi(x) belongs to phi_*(T_xM).  Then there is a vector field X (not necessarily unique) on M such that phi_*(X) = Y.  If phi is an immersion, then X is unique.

 

In the following example, the map phi defines stereographic coordinates (u, v) on the unit sphere x^2 + y^2 + z^2 = 1.  The vector field Y on M is tangent to the unit sphere and therefore is a vector X in the uv-plane which pushes forward to the restriction of Y to the unit sphere.  The vector X can be found with the PullbackVector command.

N2 > 

with(DifferentialGeometry):

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

M > 

DGsetup([u, v], N):

N > 

phi := Transformation(N, M, [x = 2*u/(1 + u^2 + v^2), y = 2*v/(1 + u^2 + v^2), z = (u^2 + v^2 -1)/(1 + u^2 + v^2)]);

φx=2u1+u2+v2,y=2v1+u2+v2,z=u2+v211+u2+v2

(4.1)
N > 

X := evalDG((y*x - z^2)*D_x - x^2*D_y + z*x*D_z);

Xyxz2D_xx2D_y+zxD_z

(4.2)

 

The following calculation shows that X is tangent to the unit sphere.

M > 

expand(LieDerivative(X, x^2 + y^2 + z^2));

0

(4.3)
M > 

Y := PullbackVector(phi, X, [D_u, D_v]);

Y1+2v2v4+4uv+u4D_u21+u2+v2+uv+vu2+v32uD_v1+u2+v2

(4.4)

 

We check that the pushforward of Y by phi (the vector Z1) and the restriction Z2 of X to the image of phi coincide.

N > 

Z1 := Pushforward(phi, Y);

Z14uv+u4+2u2v22u2+v42v2+1D_x1+u2+v224u2D_y1+u2+v22+2u2+v21uD_z1+u2+v22

(4.5)
M > 

Z2 := simplify(eval(X, [x = 2*u/(1 + u^2 + v^2), y = 2*v/(1 + u^2 + v^2), z = (u^2 + v^2 - 1)/(1 + u^2 + v^2)]));

Z24uv+u4+2u2v22u2+v42v2+1D_x1+u2+v224u2D_y1+u2+v22+2u2+v21uD_z1+u2+v22

(4.6)
M > 

Z1 &minus Z2;

0D_x

(4.7)

 

Application: The definition of the Lie bracket in terms of flows

 

Let X and Y be two vector fields with flows phi_t and psi_t.  Fix a point and define a curve sigma(t) by

 

sigma(t) = psi_(-s) o phi_(-s) o psi_(s) o phi_(s) (p),  where s = sqrt(t).

 

Then the tangent vector to sigma(t) at t = 0 coincides with the Lie bracket [X, Y](p).  We verify this result with a example.

M > 

with(DifferentialGeometry):

M3 > 

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

frame name: M

(5.1)

 

Define 2 vector fields, X and Y, and compute their Lie bracket using the LieBracket command.

M > 

X := evalDG(x*D_x - 2*y*D_y + 3*z*D_z);

XxD_x2yD_y+3zD_z

(5.2)
M > 

Y := evalDG(y*D_x + z*D_y + D_z);

YyD_x+zD_y+D_z

(5.3)
M > 

Z := LieBracket(X, Y);

Z3yD_x+5zD_y3D_z

(5.4)

 

Use the Flow command to find the flows for the vector fields X and Y.

M > 

phi := Flow(X, s);

φx=xⅇs,y=yⅇ2s,z=zⅇ3s

(5.5)
M > 

phi1 := eval(phi, s = -s);

φ1x=xⅇs,y=yⅇ2s,z=zⅇ3s

(5.6)
M > 

psi := Flow(Y, s);

ψx=s36+zs22+ys+x,y=12s2+zs+y,z=s+z

(5.7)
M > 

psi1 := eval(psi, s = -s);

ψ1x=s36+zs22ys+x,y=12s2zs+y,z=s+z

(5.8)
M > 

sigma0 := ComposeTransformations(psi1, phi1, psi, phi);

σ0x=s36+12s+zⅇ3sⅇ3ss2s22+zⅇ3ss+yⅇ2sⅇ2ss+s36+12zⅇ3ss2+yⅇ2ss+xⅇsⅇs,y=s22s+zⅇ3sⅇ3ss+s22+zⅇ3ss+yⅇ2sⅇ2s,z=s+s+zⅇ3sⅇ3s

(5.9)

 

Use the ApplyTransformation command to define the curve sigma(t) (as a list).

M > 

sigma := simplify(eval(ApplyTransformation(sigma0, [x,y,z]), s = sqrt(t)));

σt3/26+12ⅇ3tt3/2+tz212ⅇ2tt3/2ⅇ5ttzty+16ⅇtt3/2+12ⅇ2tzt+ⅇ3tyt+x,t2ⅇ3tttz+12ⅇ2tt+ⅇ5tzt+y,t+ⅇ3tt+z

(5.10)

 

Compute the derivative of the curve sigma(t) and evaluate it at t = 0 by taking the limit as t --> 0.

M > 

C := map(limit, diff(sigma, t), t=0);

C3y,5z,3

(5.11)

As claimed, these are the coefficients of the bracket vector field Z.

 

Application: The straightening theorem for vectors fields and systems of commuting vector fields

 

The straightening theorem states that if X is a vector field which is nonzero at a point p, then there are coordinates (u1, u2, u3, ...) defined in a neighborhood of p such that in these new coordinates X = D_u1.  More generally, if X1, X2, X3, ... are commuting vector fields which are linearly independent at p, then there are coordinates (u1, u2, u3, ...) defined in a neighborhood of p such that in these new coordinates X1 = D_u1, X2 = D_u2, X3 = D_u3, ....

 

These straightening coordinates are easily found if the flows of the vector fields X1, X2, X3, ... can be found -- the desired coordinates are given by the flow variables and coordinates on any submanifold transverse to the distribution spanned by the vector fields X1, X2, X3,... .  For further details see, for example, Spivak  pages 205 -- 206.

 

Example 1.  Straighten out the vector field X1.

M > 

with(DifferentialGeometry):

M > 

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

M > 

DGsetup([u1, u2, u3, u4], N):

N > 

X1 := evalDG((x - y)*D_x + u*D_y + D_u);

X1xyD_x+uD_y+D_u

(6.1)

 

Calculate the flow phi of X1.

M > 

phi := Flow(X1, t);

φx=y+u+1+ut+t+t22+ⅇtyu1+x,y=12t2+ut+y,u=t+u,v=v

(6.2)

 

The surface u = 0 is transverse to the vector field X.  Therefore our new coordinates are the flow parameter t = u1 and the coordinates u2, u3, and u4 for the surface u = 0.  We use the ApplyTransformation command to compute the flow with initial points on the surface u = 0.

M > 

F := ApplyTransformation(eval(phi, t = u1), [u2, u3, 0, u4]);

Fu3+1+u1+u122+ⅇu1u31+u2,u122+u3,u1,u4

(6.3)

 

The transformation Phi gives us a coordinate transformation that straightens out the vector field X1.

M > 

Phi := Transformation(N, M, [x = F[1], y = F[2], u = F[3], v = F[4]]);

Φx=u3+1+u1+u122+ⅇu1u31+u2,y=u122+u3,u=u1,v=u4

(6.4)

 

We use the Pushforward command to check this result.  For this we will need the inverse of the transformation Phi.

N > 

invPhi := InverseTransformation(Phi);

invPhiu1=u,u2=122x+2y+2+2u2ⅇuy+ⅇuu22ⅇuⅇu,u3=yu22,u4=v

(6.5)
M > 

Pushforward(invPhi, Phi, X1);

D_u1

(6.6)

 

Example 2.  Straighten out the vector fields X1 and X2, where X1 is the vector field from Example 1 and X2 is the vector field defined by

N > 

X2 := evalDG(exp(u)*D_x + (y - u^2/2)*D_v);

X2ⅇuD_x+yu22D_v

(6.7)

 

Let us check that the vector fields X1 and X2 commute.

M > 

LieBracket(X1, X2);

0D_x

(6.8)

 

Compute the flow psi for X2 and compose with the flow phi for X1.

M > 

psi := Flow(X2, s);

ψx=ⅇus+x,y=y,u=u,v=yu22s+v

(6.9)
M > 

chi := ComposeTransformations(psi, phi);

χx=ⅇt+us+y+u+1+ut+t+t22+ⅇtyu1+x,y=12t2+ut+y,u=t+u,v=t22+ut+yt+u22s+v

(6.10)

 

We use the combined (2 parameter) flow chi  with initial conditions on the 2 dimensional surface x = 0, u = 0 to find required the change of variables.

M > 

F := ApplyTransformation(eval(chi, {t = u1, s = u2}), [0, u3, 0, u4]);

Fⅇu1u2+u3+1+u1+u122+ⅇu1u31,u122+u3,u1,u3u2+u4

(6.11)

 

The transformation Phi defines the change of variables needed to simultaneously straighten out both vector fields X1 and X2.

M > 

Phi := Transformation(N, M, [x = F[1], y = F[2], u = F[3], v = F[4]]);

Φx=ⅇu1u2+u3+1+u1+u122+ⅇu1u31,y=u122+u3,u=u1,v=u3u2+u4

(6.12)

 

We use the Pushforward command to check this result.

N > 

invPhi := InverseTransformation(Phi);

invPhiu1=u,u2=122x+2y+2+2u2ⅇuy+ⅇuu22ⅇuⅇu,u3=yu22,u4=144vⅇu+4yx4y24y4yu+4ⅇuy24yⅇuu2+4ⅇuy2u2x+2u2y+2u2+2u3+u4ⅇu2ⅇuu2ⅇu

(6.13)
M > 

Pushforward(invPhi, Phi, X1);

D_u1

(6.14)
N > 

Pushforward(invPhi, Phi, X2);

D_u2

(6.15)

 

Exercises

Exercise 1

 

Calculate the pushforward of the vector X at the point [2, 1, 1] using the map phi by

[i]  using the Pushforward command.

[ii]  using the DGinfo command to obtain the Jacobian matrix of phi.

[iii]  first finding a curve whose tangent vector is X and then using the ComposeTransformations command.

[iv]  using the definition of pushforward as a linear transformation acting on derivations of smooth functions.

 

N > 

with(DifferentialGeometry):

N > 

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

M > 

DGsetup([u, v, w], N):

N > 

phi := Transformation(M, N, [u = x*y + z^2, v = x^2 - y^2, w = y*z + x^2]);

φu=yx+z2,v=x2y2,w=yz+x2

(7.1.1)
M > 

X := evalDG(2*D_x - 5*D_y + 3*D_z);

X2D_x5D_y+3D_z

(7.1.2)

 

Solution

 

Part [i]

M > 

Pushforward(phi, X, [x = 2, y = 1,z = 1]);

2D_u+18D_v+6D_w

(7.1.1.1)

 

Part [ii]  Use DGinfo to get the Jacobian of phi and evaluate at the point [x = 2, y = 1, z = 1]

N > 

J := Tools:-DGinfo(phi, "JacobianMatrix");

N > 

J1 := eval(J, [x = 2, y = 1, z = 1]);

 

Multiply the components of X by the Jacobian matrix to get the components of phi_*(X).

N > 

A := J1.Vector([2, -5, 3]);

N > 

DGzip(A, [D_x, D_y, D_z], "plus");

2D_x+18D_y+6D_z

(7.1.1.2)

 

Part [iii]  The curve alpha(t), given as a list, passes through the point [2, 1, 1] and is tangent to the vector X at t = 0.  The image of alpha under the mapping phi is the curve beta and the tangent vector to beta gives the components of phi_*(X).

M > 

alpha := [2*t + 2, -5*t + 1, 3*t + 1];

α2t+2,5t+1,3t+1

(7.1.1.3)
M > 

eval(alpha, t = 0);

2,1,1

(7.1.1.4)
M > 

eval(diff(alpha, t), t = 0);

2,5,3

(7.1.1.5)
M > 

beta := expand(ApplyTransformation(phi, alpha));

βt22t+3,21t2+18t+3,11t2+6t+5

(7.1.1.6)
N > 

A := eval(diff(beta, t), t = 0);

A2,18,6

(7.1.1.7)
N > 

DGzip(A, [D_x, D_y, D_z], "plus");

2D_x+18D_y+6D_z

(7.1.1.8)

 

Part [iv]  We apply the Lie derivative with respect to X to the components of phi and evaluate at [x = 2, y = 1, z = 1] to obtain the components of phi_*(X).

M > 

ComponentFunctions := ApplyTransformation(phi, [x, y, z]);

ComponentFunctionsyx+z2,x2y2,yz+x2

(7.1.1.9)
N > 

F := map2(LieDerivative, X, CoordinateFunctions);

F0

(7.1.1.10)
M > 

eval(F, [x = 2, y = 1, z = 1]);

0

(7.1.1.11)

Exercise 2

 

M > 

restart: with(DifferentialGeometry):

 

[i]  Write the vector field X1 in polar coordinates r, theta.

 

DGsetup([x, y], E2):

E2 > 

DGsetup([r, theta], Polar):

Polar > 

X1 := evalDG((x^2 - y^2)*D_x + 2*x*y*D_y);

X1x2y2D_x+2xyD_y

(7.2.1)

 

[ii]  Write the vector field X2 in spherical coordinates rho, theta, phi.

 

E2 > 

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

E3 > 

DGsetup([rho, theta, phi], Spherical):

Spherical > 

X2 := evalDG(x*z*D_x + y*z*D_y + (-x^2 - y^2)*D_z);

X2xzD_x+yzD_y+x2y2D_z

(7.2.2)

 

Solution

Part [i]

P := Transformation(Polar, E2, [x = r*cos(theta), y = r*sin(theta)]);

Px=rcosθ,y=rsinθ

(7.2.1.1)
Polar > 

_EnvExplicit := true:

Polar > 

invP := InverseTransformation(P);

invPr=y2+x2,θ=arctanyy2+x2,xy2+x2

(7.2.1.2)
E2 > 

Y1 := Pushforward(invP, P, X1);

Y1r2cosθcsgnrD_r+rsinθD_theta

(7.2.1.3)
Polar > 

map(simplify,Y1) assuming r > 0;

r2cosθD_r+rsinθD_theta

(7.2.1.4)

 

Part [ii]

Polar > 

S := Transformation(Spherical, E3, [x = rho*cos(theta)*sin(phi), y = rho*sin(theta)*sin(phi), z = rho*cos(phi)]);

Sx=ρcosθsinφ,y=ρsinθsinφ,z=ρcosφ

(7.2.1.5)
Spherical > 

invS := InverseTransformation(S);

invSρ=y2+x2+z2,θ=arctanyy2+x2+z2y2+x2+z2y2+x2,xy2+x2+z2y2+x2+z2y2+x2,φ=arctany2+x2+z2y2+x2y2+x2+z2,zy2+x2+z2

(7.2.1.6)
E3 > 

Y2 := Pushforward(invS, S, X2);

Y2csgnρρ31+cosφ2D_phiρ4sinφ2

(7.2.1.7)
Spherical > 

map(simplify, Y2) assuming rho >0, phi > 0, phi < Pi;

&rho;sin&phi;D_phi

(7.2.1.8)

Exercise 3

 

Spherical > 

restart: with(DifferentialGeometry):

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

M > 

 DGsetup([u, v], N):

 

Find, if possible, all vector fields X which pushforwards by phi to the vector field Y.

 

N > 

phi := Transformation(N, M, [x = v*cos(u), y = v*sin(u), z = v^2]);

&phi;x&equals;vcosu&comma;y&equals;vsinu&comma;z&equals;v2

(7.3.1)

 

[i]

N > 

Y1 := eval(x*D_y);

Y1xD_y

(7.3.2)

 

[ii]

M > 

Y2 := eval(x*D_x + y*D_y + 2*z*D_z);

Y2xD_x&plus;yD_y&plus;2zD_z

(7.3.3)

 

Solution

 

Part [i]

X := PullbackVector(phi, Y1, [D_u, D_v]);

X

(7.3.1.1)

The vector field Y1 is not tangent to the image of phi, that is, to the cone x^2 + y^2 = z, so no such vector field X exists.

 

Part [ii]

M > 

X := PullbackVector(phi, Y2, [D_u, D_v]);

XvD_v

(7.3.1.2)

Exercise 4

 

Write a program which checks the naturality of the Lie bracket -- that is, for any local diffeomorphism phi and vector fields X and Y,

phi_*([X, Y]) = [phi_*(X), phi_*(Y)]

 

Solution

 

with(DifferentialGeometry):

N > 

 

N > 

LieBracketNaturality := proc(phi, X, Y)

N > 

local TF, invPhi, a1, a, b1, b2, b, c;

M > 

TF := _EnvExplicit;

M > 

_EnvExplicit := true;

M > 

invPhi := InverseTransformation(phi);

M > 

_EnvExplicit := TF;

N > 

a1 := LieBracket(X, Y);

N > 

a := Pushforward(phi, invPhi, a1);

N > 

b1 := Pushforward(phi, invPhi, X);

N > 

b2 := Pushforward(phi, invPhi, Y);

N > 

c := LieBracket(b1, b2);

N > 

simplify(a &minus c);

end:

 

Test the program LieBracketNaturality

N > 

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

M > 

phi := Transformation(M, M, [x = x*y*z, y = y*z, z = 1/z]);

&phi;x&equals;xyz&comma;y&equals;yz&comma;z&equals;1z

(7.4.1.1)
M > 

X := evalDG(sin(x*z)*D_x + log(y + z)*D_y + (1/(x + y))*D_z);

XsinxzD_x&plus;lny&plus;zD_y&plus;D_zx&plus;y

(7.4.1.2)
M > 

Y := evalDG(exp(y)*x*D_x - arctan(x/z)*D_z);

Y&ExponentialE;yxD_xarctanxzD_z

(7.4.1.3)
M > 

LieBracketNaturality(phi, X, Y);

0D_x

(7.4.1.4)

Exercise 5

 

with(DifferentialGeometry):

M > 

DGsetup([x, y], M):

 

Calculate the Lie bracket of the vector fields X and Y from their flows.

 

M > 

X := evalDG(x^2*D_x + x*y*D_y);

Xx2D_x&plus;xyD_y

(7.5.1)
M > 

Y := evalDG(-x*y*D_x + y^2*D_y);

YxyD_x&plus;y2D_y

(7.5.2)

 

Solution

 

Calculate the Lie bracket directly.

M > 

LieBracket(X, Y);

2xy2D_y

(7.5.1.1)

 

Calculate the flow of X.

M > 

phi := simplify(Flow(X, t));

&phi;x&equals;xtx1&comma;y&equals;ytx1

(7.5.1.2)
M > 

phi1 := eval(phi, t = -t);

&phi;1x&equals;xtx1&comma;y&equals;ytx1

(7.5.1.3)

 

Calculate the flow of Y.

M > 

psi := simplify(Flow(Y, t));

&psi;x&equals;xty1&comma;y&equals;yty1

(7.5.1.4)
M > 

psi1 := eval(psi, t = -t);

&psi;1x&equals;xty1&comma;y&equals;yty1

(7.5.1.5)
M > 

Phi := simplify(ComposeTransformations(psi1, phi1, psi, phi));

&Phi;x&equals;x2t3yx22t2xy&plus;t3y2x&plus;t2x22tx&plus;1t2xy&plus;tx12&comma;y&equals;tx12y2t3yx22t2xy&plus;t3y2x&plus;t2x22tx&plus;1

(7.5.1.6)
M > 

C := eval(ApplyTransformation(Phi, [x, y]), t = sqrt(s)):

Z := map(limit, diff(C, s), s = 0);

Z0&comma;2xy2

Exercise 6

 

with(DifferentialGeometry):

M > 

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

 

[i]  Find coordinates which simultaneously straighten out the set of commuting vector fields {X1, X2, X3}.

[ii]  Find the joint invariants for the vector fields {X1, X2, X3}.

 

M > 

X1 := evalDG(x/(x + y + u)*D_x + y/(x + y + u)*D_y + z/(x + y + u)*D_z + u/(x + y + u)*D_u + v/(x + y + u)*D_v);

X1xD_xx&plus;y&plus;u&plus;yD_yx&plus;y&plus;u&plus;zD_zx&plus;y&plus;u&plus;uD_ux&plus;y&plus;u&plus;vD_vx&plus;y&plus;u

(7.6.1)
M > 

X2 := evalDG(-u*x/(x + y + u)*D_x + u*(x + u)/(x + y + u)*D_y - u*z/(x + y + u)*D_z - u^2/(x + y + u)*D_u - u*v/(x + y + u)*D_v);

X2uxD_xx&plus;y&plus;u&plus;ux&plus;uD_yx&plus;y&plus;uuzD_zx&plus;y&plus;uu2D_ux&plus;y&plus;uuvD_vx&plus;y&plus;u

(7.6.2)
M > 

X3 := evalDG(u*D_z);

X3uD_z

(7.6.3)

 

Solution

 

Part [i]

DGsetup([u1, u2, u3, u4, u5], N):

 

Calculate the flow of X1, X2, and X3.

N > 

phi1 := simplify(Flow(X1, u1));

&phi;1x&equals;xu1&plus;x&plus;y&plus;ux&plus;y&plus;u&comma;y&equals;yu1&plus;x&plus;y&plus;ux&plus;y&plus;u&comma;z&equals;zu1&plus;x&plus;y&plus;ux&plus;y&plus;u&comma;u&equals;uu1&plus;x&plus;y&plus;ux&plus;y&plus;u&comma;v&equals;vu1&plus;x&plus;y&plus;ux&plus;y&plus;u

(7.6.1.1)
M > 

phi2 := simplify(Flow(X2, u2));

&phi;2x&equals;xx&plus;y&plus;uu2u&plus;x&plus;y&plus;u&comma;y&equals;x&plus;y&plus;uu2u&plus;yu2u&plus;x&plus;y&plus;u&comma;z&equals;zx&plus;y&plus;uu2u&plus;x&plus;y&plus;u&comma;u&equals;x&plus;y&plus;uuu2u&plus;x&plus;y&plus;u&comma;v&equals;vx&plus;y&plus;uu2u&plus;x&plus;y&plus;u

(7.6.1.2)
M > 

phi3 := simplify(Flow(X3, u3));

&phi;3x&equals;x&comma;y&equals;y&comma;z&equals;uu3&plus;z&comma;u&equals;u&comma;v&equals;v

(7.6.1.3)

 

Compose these 3 flows.

M > 

A := ComposeTransformations(phi3, phi2, phi1):

 

Apply the combined flow to the points [1, 0, 0, u4, u5].

M > 

B := simplify(ApplyTransformation(A, [1, 0, 0, u4, u5]));

Bu1&plus;1&plus;u4u2u4&plus;1&plus;u4&comma;u2u4u1&plus;1&plus;u4u2u4&plus;1&plus;u4&comma;u4u1&plus;1&plus;u4u3u2u4&plus;1&plus;u4&comma;u4u1&plus;1&plus;u4u2u4&plus;1&plus;u4&comma;u1&plus;1&plus;u4u5u2u4&plus;1&plus;u4

(7.6.1.4)
M > 

vars := [x, y, z, u, v]:

M > 

F := Transformation(N, M, [seq(vars[i] = B[i], i = 1 .. 5)]);

Fx&equals;u1&plus;1&plus;u4u2u4&plus;1&plus;u4&comma;y&equals;u2u4u1&plus;1&plus;u4u2u4&plus;1&plus;u4&comma;z&equals;u4u1&plus;1&plus;u4u3u2u4&plus;1&plus;u4&comma;u&equals;u4u1&plus;1&plus;u4u2u4&plus;1&plus;u4&comma;v&equals;u1&plus;1&plus;u4u5u2u4&plus;1&plus;u4

(7.6.1.5)

 

Check that the change of variables defined by F does indeed straighten out the vectors X1, X2, X3.

N > 

invF := InverseTransformation(F, "all");

invFu1&equals;xy&plus;x2&plus;xuxux&comma;u2&equals;yu&comma;u3&equals;zu&comma;u4&equals;ux&comma;u5&equals;vx

(7.6.1.6)
M > 

Pushforward(invF, F, X1), Pushforward(invF, F, X2), Pushforward(invF, F, X3);

D_u1&comma;D_u2&comma;D_u3

(7.6.1.7)

 

Part [ii]  The invariants in the coordinate system N are obviously u4 and u5, which in terms of the original variables are u/x and y/v.  We check that these are the invariants.

N > 

Matrix(3, 2, (i, j) -> LieDerivative([X1, X2, X3][i], [u/x, v/x][j]));

Exercise 7

 

In Lesson 5, we constructed the left and right invariant vector fields for the matrix group defined by the matrix A.

 

with(DifferentialGeometry): DGsetup([x1, x2, x3], G):

G > 

A := Matrix([[exp(-x1), -x1*exp(-x1), x2], [0, exp(-x1), x3], [0, 0, 1]]);

G > 

XL := [D_x1, exp(-x1)*D_x2, -x1*exp(-x1)*D_x2 + exp(-x1)*D_x3];

XLD_x1&comma;&ExponentialE;x1D_x2&comma;x1&ExponentialE;x1D_x2&plus;&ExponentialE;x1D_x3

(7.7.1)
G > 

XR := [D_x1 + (-x3 - x2)*D_x2 - x3*D_x3, D_x2, D_x3];

XRD_x1&plus;x3x2D_x2x3D_x3&comma;D_x2&comma;D_x3

(7.7.2)

 

[i]  Check the invariance of these vector fields using the Pushforward map.

[ii]  Re-derive these formulas for the left and right invariant vector fields using the Pushforward map.

Hint: We calculated the multiplication rule [z1, z2, z3] = [x1, x2, x3]*[y1, y2, y3] to be the following.  Use this to define transformations from G to G giving left and right multiplications by [a1, a2, a3].

 

G > 

MultiplicationRule := [z3 = (y3 + x3*exp(x1))/exp(x1), z2 = (y2 - x1*y3 + x2*exp(x1))/exp(x1), z1 = x1 + y1];

MultiplicationRulez3&equals;y3&plus;x3&ExponentialE;x1&ExponentialE;x1&comma;z2&equals;y2x1y3&plus;x2&ExponentialE;x1&ExponentialE;x1&comma;z1&equals;x1&plus;y1

(7.7.3)

 

Solution

 

Part [i]  Define right multiplication by [a1, a2, a3].

G > 

mult := eval(MultiplicationRule, [y1 = a1, y2 = a2, y3 = a3, z1 = x1, z2 = x2, z3 = x3]):

G > 

RightMult := Transformation(G, G, mult);

RightMultx1&equals;x1&plus;a1&comma;x2&equals;a2x1a3&plus;x2&ExponentialE;x1&ExponentialE;x1&comma;x3&equals;a3&plus;x3&ExponentialE;x1&ExponentialE;x1

(7.7.1.1)

 

Define left multiplication by [a1, a2, a3].

G > 

mult := eval(MultiplicationRule, [x1 = a1, x2 = a2, x3 = a3, z1 = x1, z2 = x2, z3 = x3]):

G > 

mult := eval(mult, [y1 = x1, y2 = x2, y3 = x3]):

G > 

LeftMult := Transformation(G, G, mult);

LeftMultx1&equals;x1&plus;a1&comma;x2&equals;x2a1x3&plus;a2&ExponentialE;a1&ExponentialE;a1&comma;x3&equals;x3&plus;a3&ExponentialE;a1&ExponentialE;a1

(7.7.1.2)

 

To check the invariance of the vector fields XL under left multiplication, we pushforward the vectors using LeftMult to obtain vector fields at the point p = a.x and compare the result with vector fields XL evaluated at p.

G > 

pushXL := map2(Pushforward, LeftMult, XL);

pushXLD_x1&comma;&ExponentialE;x1a1D_x2&comma;&ExponentialE;x1a1x1&plus;a1D_x2&plus;&ExponentialE;x1a1D_x3

(7.7.1.3)
G > 

p := ApplyTransformation(LeftMult, [x1 = x1, x1 = x1, x1 = x1]);

px1&equals;x1&plus;a1&comma;x2&equals;x2a1x3&plus;a2&ExponentialE;a1&ExponentialE;a1&comma;x3&equals;x3&plus;a3&ExponentialE;a1&ExponentialE;a1

(7.7.1.4)
G > 

evalXL := eval(XL, p);

evalXLD_x1&comma;&ExponentialE;x1a1D_x2&comma;x1&plus;a1&ExponentialE;x1a1D_x2&plus;&ExponentialE;x1a1D_x3

(7.7.1.5)
G > 

seq(pushXL[i] &minus evalXL[i], i = 1 .. 3);

0D_x1&comma;0D_x1&comma;0D_x1

(7.7.1.6)

 

Likewise, to check the invariance of the vector fields XR under right multiplication, we pushforward the vectors using RightMult to obtain vector fields at the point p = x.a and compare the result with vector fields XR evaluated at p.

G > 

pushXR := map2(Pushforward, RightMult, XR);

pushXRD_x1&plus;x3x2&ExponentialE;x1a3&ExponentialE;x1a2&plus;&ExponentialE;x1x1a3D_x2&plus;x3&ExponentialE;x1a3D_x3&comma;D_x2&comma;D_x3

(7.7.1.7)
G > 

p := ApplyTransformation(RightMult, [x1 = x1, x1 = x1, x1 = x1]);

px1&equals;x1&plus;a1&comma;x2&equals;a2x1a3&plus;x2&ExponentialE;x1&ExponentialE;x1&comma;x3&equals;a3&plus;x3&ExponentialE;x1&ExponentialE;x1

(7.7.1.8)
G > 

evalXR := eval(XR, p);

evalXRD_x1&plus;a3&plus;x3&ExponentialE;x1&ExponentialE;x1a2x1a3&plus;x2&ExponentialE;x1&ExponentialE;x1D_x2a3&plus;x3&ExponentialE;x1D_x3&ExponentialE;x1&comma;D_x2&comma;D_x3

(7.7.1.9)
G > 

seq(pushXR[i] &minus evalXR[i], i = 1 .. 3);

0D_x1&comma;0D_x1&comma;0D_x1

(7.7.1.10)

 

Part [ii]  We use the fact that if L_a(x) = a*x is left multiplication, and X_0 is a vector at the identity then the vector field defined by X(a) = (L_a)_*(e)(X0) is always left invariant.

G > 

XL1 := map2(Pushforward, LeftMult, [D_x1, D_x2, D_x3], [x1 = 0, x2 = 0, x3 = 0]);

XL1D_x1&comma;&ExponentialE;a1D_x2&comma;a1&ExponentialE;a1D_x2&plus;&ExponentialE;a1D_x3

(7.7.1.11)

 

Replace [a1, a2, a3] by [x1, x2, x3] to obtain the left invariant vector fields.

G > 

XL2 := eval(XL1, [a1 = x1, a2 = x2, a3 = x3]);

XL2D_x1&comma;&ExponentialE;x1D_x2&comma;x1&ExponentialE;x1D_x2&plus;&ExponentialE;x1D_x3

(7.7.1.12)
G > 

XR1 := map2(Pushforward, RightMult, [D_x1, D_x2, D_x3], [x1 = 0, x2 = 0, x3 = 0]);

XR1D_x1&plus;a3a2D_x2a3D_x3&comma;D_x2&comma;D_x3

(7.7.1.13)

 

Replace [a1, a2, a3] by [x1, x2, x3] to obtain the right invariant vector fields.

G > 

XR2 := eval(XR1, [a1 = x1, a2 = x2, a3 = x3]);

XR2D_x1&plus;x3x2D_x2x3D_x3&comma;D_x2&comma;D_x3

(7.7.1.14)