DifferentialGeometry Lessons
Lesson 7: The Pushforward of a Vector by a Transformation
|
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, z], M3):
|
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)]);
|
| (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]);
|
| (2.2) |
M3 >
|
simplify(P[1]^2 + P[2]^2 + P[3]^2);
|
| (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);
|
| (2.4) |
N >
|
Y1 := Pushforward(phi, X, [u = 1, v = 2]);
|
| (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");
|
| (2.6) |
M3 >
|
Jpt := eval(J, [u = 1, v = 2]);
|
| (2.7) |
M3 >
|
B := Jpt.Vector([a, b]);
|
| (2.8) |
M3 >
|
Z1 := DGzip(convert(B, list), [D_x, D_y, D_z], "plus");
|
| (2.9) |
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);
|
| (2.10) |
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);
|
| (2.11) |
N >
|
sigma2 := ComposeTransformations(phi, sigma1);
|
| (2.12) |
N >
|
Z2 := InfinitesimalTransformation(sigma2, [t]);
|
| (2.13) |
| (2.14) |
We can also compute the components of the vector Y2 by applying the LieDerivative command to the components of the map phi.
| (2.15) |
M3 >
|
C := simplify(map2(LieDerivative, X, P));
|
| (2.16) |
N >
|
Z3 := DGzip(C, [D_x, D_y, D_z], "plus");
|
| (2.17) |
| (2.18) |
|
|
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):
|
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)]);
|
| (3.1) |
We need the inverse of phi.
M2 >
|
_EnvExplicit := true;
|
| (3.2) |
M2 >
|
psi := InverseTransformation(phi);
|
| (3.3) |
M2 >
|
X := evalDG((1/x)*D_x);
|
| (3.4) |
M2 >
|
Y := Pushforward(phi, psi, X);
|
| (3.5) |
Case 2. Example 1.
M3 >
|
Delta := [D_x, D_y];
|
| (3.6) |
M3 >
|
X := evalDG(z*D_x + z^2*D_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]);
|
| (3.8) |
M3 >
|
sigma := Transformation(M1, M3, [x = a, y = b, z = z]);
|
| (3.9) |
M1 >
|
Pushforward(pi, sigma, X);
|
| (3.10) |
Case 2. Example 2. This example is slightly more complicated.
M4 >
|
Delta := evalDG([x*D_x + y*D_y + z*D_z + w*D_w, y*D_x - x*D_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);
|
| (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])));
|
| (3.13) |
Define the projection map.
M4 >
|
pi := Transformation(M4, N2, [u = F1, v = F2]);
|
| (3.14) |
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]);
|
| (3.15) |
N2 >
|
ComposeTransformations(pi, sigma);
|
| (3.16) |
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);
|
| (3.17) |
M4 >
|
map2(LieDerivative, Z, Delta);
|
| (3.18) |
M4 >
|
Pushforward(pi, sigma, Z);
|
| (3.19) |
|
|
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):
|
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)]);
|
| (4.1) |
N >
|
X := evalDG((y*x - z^2)*D_x - x^2*D_y + z*x*D_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));
|
| (4.3) |
M >
|
Y := PullbackVector(phi, X, [D_u, D_v]);
|
| (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);
|
| (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)]));
|
| (4.6) |
| (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);
|
| (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);
|
| (5.2) |
M >
|
Y := evalDG(y*D_x + z*D_y + D_z);
|
| (5.3) |
M >
|
Z := LieBracket(X, Y);
|
| (5.4) |
Use the Flow command to find the flows for the vector fields X and Y.
| (5.5) |
M >
|
phi1 := eval(phi, s = -s);
|
| (5.6) |
| (5.7) |
M >
|
psi1 := eval(psi, s = -s);
|
| (5.8) |
M >
|
sigma0 := ComposeTransformations(psi1, phi1, psi, phi);
|
| (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)));
|
| (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);
|
| (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);
|
| (6.1) |
Calculate the flow phi of X1.
| (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]);
|
| (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]]);
|
| (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);
|
| (6.5) |
M >
|
Pushforward(invPhi, Phi, X1);
|
| (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);
|
| (6.7) |
Let us check that the vector fields X1 and X2 commute.
| (6.8) |
Compute the flow psi for X2 and compose with the flow phi for X1.
| (6.9) |
M >
|
chi := ComposeTransformations(psi, phi);
|
| (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]);
|
| (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]]);
|
| (6.12) |
We use the Pushforward command to check this result.
N >
|
invPhi := InverseTransformation(Phi);
|
| (6.13) |
M >
|
Pushforward(invPhi, Phi, X1);
|
| (6.14) |
N >
|
Pushforward(invPhi, Phi, X2);
|
| (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]);
|
| (7.1.1) |
M >
|
X := evalDG(2*D_x - 5*D_y + 3*D_z);
|
| (7.1.2) |
|
Solution
|
|
Part [i]
M >
|
Pushforward(phi, X, [x = 2, y = 1,z = 1]);
|
| (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");
|
| (7.1.1.2) |
N >
|
J1 := eval(J, [x = 2, y = 1, z = 1]);
|
| (7.1.1.3) |
Multiply the components of X by the Jacobian matrix to get the components of phi_*(X).
N >
|
A := J1.Vector([2, -5, 3]);
|
| (7.1.1.4) |
N >
|
DGzip(A, [D_x, D_y, D_z], "plus");
|
| (7.1.1.5) |
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];
|
| (7.1.1.6) |
| (7.1.1.7) |
M >
|
eval(diff(alpha, t), t = 0);
|
| (7.1.1.8) |
M >
|
beta := expand(ApplyTransformation(phi, alpha));
|
| (7.1.1.9) |
N >
|
A := eval(diff(beta, t), t = 0);
|
| (7.1.1.10) |
N >
|
DGzip(A, [D_x, D_y, D_z], "plus");
|
| (7.1.1.11) |
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]);
|
| (7.1.1.12) |
N >
|
F := map2(LieDerivative, X, CoordinateFunctions);
|
| (7.1.1.13) |
M >
|
eval(F, [x = 2, y = 1, z = 1]);
|
| (7.1.1.14) |
|
|
|
Exercise 2
|
|
M >
|
restart: with(DifferentialGeometry):
|
[i] Write the vector field X1 in polar coordinates r, theta.
E2 >
|
DGsetup([r, theta], Polar):
|
Polar >
|
X1 := evalDG((x^2 - y^2)*D_x + 2*x*y*D_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);
|
| (7.2.2) |
|
Solution
|
|
Part [i]
>
|
P := Transformation(Polar, E2, [x = r*cos(theta), y = r*sin(theta)]);
|
| (7.2.1.1) |
Polar >
|
_EnvExplicit := true:
|
Polar >
|
invP := InverseTransformation(P);
|
| (7.2.1.2) |
E2 >
|
Y1 := Pushforward(invP, P, X1);
|
| (7.2.1.3) |
Polar >
|
map(simplify,Y1) assuming r > 0;
|
| (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)]);
|
| (7.2.1.5) |
Spherical >
|
invS := InverseTransformation(S);
|
| (7.2.1.6) |
E3 >
|
Y2 := Pushforward(invS, S, X2);
|
| (7.2.1.7) |
Spherical >
|
map(simplify, Y2) assuming rho >0, phi > 0, phi < Pi;
|
| (7.2.1.8) |
|
|
|
Exercise 3
|
|
Spherical >
|
restart: with(DifferentialGeometry):
|
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]);
|
| (7.3.1) |
[i]
| (7.3.2) |
[ii]
M >
|
Y2 := eval(x*D_x + y*D_y + 2*z*D_z);
|
| (7.3.3) |
|
Solution
|
|
Part [i]
>
|
X := PullbackVector(phi, Y1, [D_u, D_v]);
|
| (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]);
|
| (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 >
|
LieBracketNaturality := proc(phi, X, Y)
|
N >
|
local TF, invPhi, a1, a, b1, b2, b, c;
|
M >
|
_EnvExplicit := true;
|
M >
|
invPhi := InverseTransformation(phi);
|
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);
|
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]);
|
| (7.4.1.1) |
M >
|
X := evalDG(sin(x*z)*D_x + log(y + z)*D_y + (1/(x + y))*D_z);
|
| (7.4.1.2) |
M >
|
Y := evalDG(exp(y)*x*D_x - arctan(x/z)*D_z);
|
| (7.4.1.3) |
M >
|
LieBracketNaturality(phi, X, Y);
|
| (7.4.1.4) |
|
|
|
Exercise 5
|
|
>
|
with(DifferentialGeometry):
|
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);
|
| (7.5.1) |
M >
|
Y := evalDG(-x*y*D_x + y^2*D_y);
|
| (7.5.2) |
|
Solution
|
|
Calculate the Lie bracket directly.
| (7.5.1.1) |
Calculate the flow of X.
M >
|
phi := simplify(Flow(X, t));
|
| (7.5.1.2) |
M >
|
phi1 := eval(phi, t = -t);
|
| (7.5.1.3) |
Calculate the flow of Y.
M >
|
psi := simplify(Flow(Y, t));
|
| (7.5.1.4) |
M >
|
psi1 := eval(psi, t = -t);
|
| (7.5.1.5) |
M >
|
Phi := simplify(ComposeTransformations(psi1, phi1, psi, phi));
|
| (7.5.1.6) |
M >
|
C := eval(ApplyTransformation(Phi, [x, y]), t = sqrt(s)):
|
Z := map(limit, diff(C, s), s = 0);
|
|
|
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);
|
| (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);
|
| (7.6.2) |
| (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));
|
| (7.6.1.1) |
M >
|
phi2 := simplify(Flow(X2, u2));
|
| (7.6.1.2) |
M >
|
phi3 := simplify(Flow(X3, u3));
|
| (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]));
|
| (7.6.1.4) |
M >
|
vars := [x, y, z, u, v]:
|
M >
|
F := Transformation(N, M, [seq(vars[i] = B[i], i = 1 .. 5)]);
|
| (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");
|
| (7.6.1.6) |
M >
|
Pushforward(invF, F, X1), Pushforward(invF, F, X2), Pushforward(invF, F, X3);
|
| (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]));
|
| (7.6.1.8) |
|
|
|
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]]);
|
| (7.7.1) |
G >
|
XL := [D_x1, exp(-x1)*D_x2, -x1*exp(-x1)*D_x2 + exp(-x1)*D_x3];
|
| (7.7.2) |
G >
|
XR := [D_x1 + (-x3 - x2)*D_x2 - x3*D_x3, D_x2, D_x3];
|
| (7.7.3) |
[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];
|
| (7.7.4) |
|
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);
|
| (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);
|
| (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);
|
| (7.7.1.3) |
G >
|
p := ApplyTransformation(LeftMult, [x1 = x1, x1 = x1, x1 = x1]);
|
| (7.7.1.4) |
G >
|
evalXL := eval(XL, p);
|
| (7.7.1.5) |
G >
|
seq(pushXL[i] &minus evalXL[i], i = 1 .. 3);
|
| (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);
|
| (7.7.1.7) |
G >
|
p := ApplyTransformation(RightMult, [x1 = x1, x1 = x1, x1 = x1]);
|
| (7.7.1.8) |
G >
|
evalXR := eval(XR, p);
|
| (7.7.1.9) |
G >
|
seq(pushXR[i] &minus evalXR[i], i = 1 .. 3);
|
| (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]);
|
| (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]);
|
| (7.7.1.12) |
G >
|
XR1 := map2(Pushforward, RightMult, [D_x1, D_x2, D_x3], [x1 = 0, x2 = 0, x3 = 0]);
|
| (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]);
|
| (7.7.1.14) |
|
|
|
�Ian M. Anderson 2006
|