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
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.
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):
DGsetup([u, v], N):
DGsetup([x, y, z], M3):
Define a transformation phi from N to M3.
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=2⁢u1+u2+v2,y=2⁢v1+u2+v2,z=u2+v2−11+u2+v2
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.
P := ApplyTransformation(phi, [u, v]);
P ≔ 2⁢u1+u2+v2,2⁢v1+u2+v2,u2+v2−11+u2+v2
simplify(P[1]^2 + P[2]^2 + P[3]^2);
1
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.
X := evalDG(a*D_u + b*D_v);
X ≔ a⁢D_u+b⁢D_v
Y1 := Pushforward(phi, X, [u = 1, v = 2]);
Y1 ≔ −2⁢b9+2⁢a9⁢D_x+−b9−2⁢a9⁢D_y+2⁢b9+a9⁢D_z
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].
J := Tools:-DGinfo(phi, "JacobianMatrix");
Jpt := eval(J, [u = 1, v = 2]);
B := Jpt.Vector([a, b]);
Z1 := DGzip(convert(B, list), [D_x, D_y, D_z], "plus");
Z1 ≔ −2⁢b9+2⁢a9⁢D_x+−b9−2⁢a9⁢D_y+2⁢b9+a9⁢D_z
The vectors Y1 and Z1 coincide.
To pushforward the vector X at a generic point [u, v], we can use Pushforward with 2 arguments.
Y2 := Pushforward(phi, X);
Y2 ≔ 2⁢−2⁢b⁢u⁢v+a−a⁢u2+a⁢v2⁢D_x1+u2+v22−2⁢−b−b⁢u2+b⁢v2+2⁢a⁢u⁢v⁢D_y1+u2+v22+4⁢b⁢v+a⁢u⁢D_z1+u2+v22
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.
sigma1 := Flow(X, t);
σ1 ≔ u=a⁢t+u,v=b⁢t+v
sigma2 := ComposeTransformations(phi, sigma1);
σ2 ≔ x=2⁢a⁢t+u1+a⁢t+u2+b⁢t+v2,y=2⁢b⁢t+v1+a⁢t+u2+b⁢t+v2,z=a⁢t+u2+b⁢t+v2−11+a⁢t+u2+b⁢t+v2
Z2 := InfinitesimalTransformation(sigma2, [t]);
Z2 ≔ 2⁢−2⁢b⁢u⁢v+a−a⁢u2+a⁢v2⁢D_x1+u2+v22−2⁢−b−b⁢u2+b⁢v2+2⁢a⁢u⁢v⁢D_y1+u2+v22+4⁢b⁢v+a⁢u⁢D_z1+u2+v22
Y2 &minus Z2[1];
0⁢D_x
We can also compute the components of the vector Y2 by applying the LieDerivative command to the components of the map phi.
P;
2⁢u1+u2+v2,2⁢v1+u2+v2,u2+v2−11+u2+v2
C := simplify(map2(LieDerivative, X, P));
C ≔ 2⁢−2⁢b⁢u⁢v+a−a⁢u2+a⁢v21+u2+v22,−2⁢−b−b⁢u2+b⁢v2+2⁢a⁢u⁢v1+u2+v22,4⁢b⁢v+a⁢u1+u2+v22
Z3 := DGzip(C, [D_x, D_y, D_z], "plus");
Z3 ≔ 2⁢−2⁢b⁢u⁢v+a−a⁢u2+a⁢v2⁢D_x1+u2+v22−2⁢−b−b⁢u2+b⁢v2+2⁢a⁢u⁢v⁢D_y1+u2+v22+4⁢b⁢v+a⁢u⁢D_z1+u2+v22
Y2 &minus Z3;
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.
DGsetup([x, y, z, w], M4):
DGsetup([z], 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.
phi := Transformation(M2, N2,[u = 1/2*(x^2 + y^2), v = 1/2*(x^2 - y^2)]);
φ ≔ u=x22+y22,v=x22−y22
We need the inverse of phi.
_EnvExplicit := true;
_EnvExplicit ≔ true
psi := InverseTransformation(phi);
ψ ≔ x=v+u,y=u−v
ChangeFrame(M2):
X := evalDG((1/x)*D_x);
X ≔ D_xx
Y := Pushforward(phi, psi, X);
Y ≔ D_u+D_v
Case 2. Example 1.
ChangeFrame(M3):
Delta := [D_x, D_y];
Δ ≔ D_x,D_y
X := evalDG(z*D_x + z^2*D_z);
X ≔ z⁢D_x+z2⁢D_z
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.
pi := Transformation(M3, M1, [z = z]);
π ≔ z=z
sigma := Transformation(M1, M3, [x = a, y = b, z = z]);
σ ≔ x=a,y=b,z=z
Pushforward(pi, sigma, X);
z2⁢D_z
Case 2. Example 2. This example is slightly more complicated.
ChangeFrame(M4):
Delta := evalDG([x*D_x + y*D_y + z*D_z + w*D_w, y*D_x - x*D_y]);
Δ ≔ x⁢D_x+y⁢D_y+z⁢D_z+w⁢D_w,y⁢D_x−x⁢D_y
We use the LieBracket and GetComponents commands to check that Delta is a rank 2 integrable distribution.
GetComponents(LieBracket(Delta[1], Delta[2]), Delta);
0,0
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).
F1 := z/sqrt(x^2 + y^2):
F2 := w/sqrt(x^2 + y^2):
Check that F1 and F2 are the invariants.
Matrix(2, 2, (i, j) -> simplify(LieDerivative(Delta[i], [F1, F2][j])));
Define the projection map.
pi := Transformation(M4, N2, [u = F1, v = F2]);
π ≔ u=zx2+y2,v=wx2+y2
Define the cross-section sigma and check that pi o sigma is the identity on N2.
sigma := Transformation(N2, M4, [x = 1, y = 0 , z = u, w = v]);
σ ≔ x=1,y=0,z=u,w=v
ComposeTransformations(pi, sigma);
u=u,v=v
The following vector field preserves the distribution Delta and therefore projects under pi to a vector field on N2.
Z := evalDG(x*D_x + y*D_y + a*w*D_z + b*z^2*w/(x^2 + y^2)*D_w);
Z ≔ x⁢D_x+y⁢D_y+a⁢w⁢D_z+b⁢z2⁢w⁢D_wx2+y2
map2(LieDerivative, Z, Delta);
0⁢D_x,0⁢D_x
Pushforward(pi, sigma, Z);
a⁢v−u⁢D_u+v⁢b⁢u2−1⁢D_v
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.
DGsetup([x, y, z], M):
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 := evalDG((y*x - z^2)*D_x - x^2*D_y + z*x*D_z);
X ≔ y⁢x−z2⁢D_x−x2⁢D_y+z⁢x⁢D_z
The following calculation shows that X is tangent to the unit sphere.
expand(LieDerivative(X, x^2 + y^2 + z^2));
0
Y := PullbackVector(phi, X, [D_u, D_v]);
Y ≔ −1+2⁢v2−v4+4⁢u⁢v+u4⁢D_u2⁢1+u2+v2+u⁢−v+v⁢u2+v3−2⁢u⁢D_v1+u2+v2
We check that the pushforward of Y by phi (the vector Z1) and the restriction Z2 of X to the image of phi coincide.
Z1 := Pushforward(phi, Y);
Z1 ≔ −−4⁢u⁢v+u4+2⁢u2⁢v2−2⁢u2+v4−2⁢v2+1⁢D_x1+u2+v22−4⁢u2⁢D_y1+u2+v22+2⁢u2+v2−1⁢u⁢D_z1+u2+v22
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)]));
Z2 ≔ −−4⁢u⁢v+u4+2⁢u2⁢v2−2⁢u2+v4−2⁢v2+1⁢D_x1+u2+v22−4⁢u2⁢D_y1+u2+v22+2⁢u2+v2−1⁢u⁢D_z1+u2+v22
Z1 &minus Z2;
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.
DGsetup([x, y, z], M);
frame name: M
Define 2 vector fields, X and Y, and compute their Lie bracket using the LieBracket command.
X := evalDG(x*D_x - 2*y*D_y + 3*z*D_z);
X ≔ x⁢D_x−2⁢y⁢D_y+3⁢z⁢D_z
Y := evalDG(y*D_x + z*D_y + D_z);
Y ≔ y⁢D_x+z⁢D_y+D_z
Z := LieBracket(X, Y);
Z ≔ −3⁢y⁢D_x+5⁢z⁢D_y−3⁢D_z
Use the Flow command to find the flows for the vector fields X and Y.
phi := Flow(X, s);
φ ≔ x=x⁢ⅇs,y=y⁢ⅇ−2⁢s,z=z⁢ⅇ3⁢s
phi1 := eval(phi, s = -s);
φ1 ≔ x=x⁢ⅇ−s,y=y⁢ⅇ2⁢s,z=z⁢ⅇ−3⁢s
psi := Flow(Y, s);
ψ ≔ x=s36+z⁢s22+y⁢s+x,y=12⁢s2+z⁢s+y,z=s+z
psi1 := eval(psi, s = -s);
ψ1 ≔ x=−s36+z⁢s22−y⁢s+x,y=12⁢s2−z⁢s+y,z=−s+z
sigma0 := ComposeTransformations(psi1, phi1, psi, phi);
σ0 ≔ x=−s36+12⁢s+z⁢ⅇ3⁢s⁢ⅇ−3⁢s⁢s2−s22+z⁢ⅇ3⁢s⁢s+y⁢ⅇ−2⁢s⁢ⅇ2⁢s⁢s+s36+12⁢z⁢ⅇ3⁢s⁢s2+y⁢ⅇ−2⁢s⁢s+x⁢ⅇs⁢ⅇ−s,y=s22−s+z⁢ⅇ3⁢s⁢ⅇ−3⁢s⁢s+s22+z⁢ⅇ3⁢s⁢s+y⁢ⅇ−2⁢s⁢ⅇ2⁢s,z=−s+s+z⁢ⅇ3⁢s⁢ⅇ−3⁢s
Use the ApplyTransformation command to define the curve sigma(t) (as a list).
sigma := simplify(eval(ApplyTransformation(sigma0, [x,y,z]), s = sqrt(t)));
σ ≔ −t3/26+12⁢ⅇ−3⁢t⁢t3/2+t⁢z2−12⁢ⅇ2⁢t⁢t3/2−ⅇ5⁢t⁢t⁢z−t⁢y+16⁢ⅇ−t⁢t3/2+12⁢ⅇ2⁢t⁢z⁢t+ⅇ−3⁢t⁢y⁢t+x,t2−ⅇ−3⁢t⁢t−t⁢z+12⁢ⅇ2⁢t⁢t+ⅇ5⁢t⁢z⁢t+y,−t+ⅇ−3⁢t⁢t+z
Compute the derivative of the curve sigma(t) and evaluate it at t = 0 by taking the limit as t --> 0.
C := map(limit, diff(sigma, t), t=0);
C ≔ −3⁢y,5⁢z,−3
As claimed, these are the coefficients of the bracket vector field Z.
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.
DGsetup([x, y, u, v], M):
DGsetup([u1, u2, u3, u4], N):
X1 := evalDG((x - y)*D_x + u*D_y + D_u);
X1 ≔ x−y⁢D_x+u⁢D_y+D_u
Calculate the flow phi of X1.
phi := Flow(X1, t);
φ ≔ x=y+u+1+u⁢t+t+t22+ⅇt⁢−y−u−1+x,y=12⁢t2+u⁢t+y,u=t+u,v=v
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.
F := ApplyTransformation(eval(phi, t = u1), [u2, u3, 0, u4]);
F ≔ u3+1+u1+u122+ⅇu1⁢−u3−1+u2,u122+u3,u1,u4
The transformation Phi gives us a coordinate transformation that straightens out the vector field X1.
Phi := Transformation(N, M, [x = F[1], y = F[2], u = F[3], v = F[4]]);
Φ ≔ x=u3+1+u1+u122+ⅇu1⁢−u3−1+u2,y=u122+u3,u=u1,v=u4
We use the Pushforward command to check this result. For this we will need the inverse of the transformation Phi.
invPhi := InverseTransformation(Phi);
invPhi ≔ u1=u,u2=−12⁢−2⁢x+2⁢y+2+2⁢u−2⁢ⅇu⁢y+ⅇu⁢u2−2⁢ⅇuⅇu,u3=y−u22,u4=v
Pushforward(invPhi, Phi, X1);
D_u1
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
X2 := evalDG(exp(u)*D_x + (y - u^2/2)*D_v);
X2 ≔ ⅇu⁢D_x+y−u22⁢D_v
Let us check that the vector fields X1 and X2 commute.
LieBracket(X1, X2);
Compute the flow psi for X2 and compose with the flow phi for X1.
psi := Flow(X2, s);
ψ ≔ x=ⅇu⁢s+x,y=y,u=u,v=y−u22⁢s+v
chi := ComposeTransformations(psi, phi);
χ ≔ x=ⅇt+u⁢s+y+u+1+u⁢t+t+t22+ⅇt⁢−y−u−1+x,y=12⁢t2+u⁢t+y,u=t+u,v=t22+u⁢t+y−t+u22⁢s+v
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.
F := ApplyTransformation(eval(chi, {t = u1, s = u2}), [0, u3, 0, u4]);
F ≔ ⅇu1⁢u2+u3+1+u1+u122+ⅇu1⁢−u3−1,u122+u3,u1,u3⁢u2+u4
The transformation Phi defines the change of variables needed to simultaneously straighten out both vector fields X1 and X2.
Φ ≔ x=ⅇu1⁢u2+u3+1+u1+u122+ⅇu1⁢−u3−1,y=u122+u3,u=u1,v=u3⁢u2+u4
We use the Pushforward command to check this result.
invPhi ≔ u1=u,u2=−12⁢−2⁢x+2⁢y+2+2⁢u−2⁢ⅇu⁢y+ⅇu⁢u2−2⁢ⅇuⅇu,u3=y−u22,u4=−14⁢−4⁢v⁢ⅇu+4⁢y⁢x−4⁢y2−4⁢y−4⁢y⁢u+4⁢ⅇu⁢y2−4⁢y⁢ⅇu⁢u2+4⁢ⅇu⁢y−2⁢u2⁢x+2⁢u2⁢y+2⁢u2+2⁢u3+u4⁢ⅇu−2⁢ⅇu⁢u2ⅇu
Pushforward(invPhi, Phi, X2);
D_u2
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.
DGsetup([u, v, w], N):
phi := Transformation(M, N, [u = x*y + z^2, v = x^2 - y^2, w = y*z + x^2]);
φ ≔ u=y⁢x+z2,v=x2−y2,w=y⁢z+x2
X := evalDG(2*D_x - 5*D_y + 3*D_z);
X ≔ 2⁢D_x−5⁢D_y+3⁢D_z
Solution
Part [i]
Pushforward(phi, X, [x = 2, y = 1,z = 1]);
−2⁢D_u+18⁢D_v+6⁢D_w
Part [ii] Use DGinfo to get the Jacobian of phi and evaluate at the point [x = 2, y = 1, z = 1]
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).
A := J1.Vector([2, -5, 3]);
DGzip(A, [D_x, D_y, D_z], "plus");
−2⁢D_x+18⁢D_y+6⁢D_z
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).
alpha := [2*t + 2, -5*t + 1, 3*t + 1];
α ≔ 2⁢t+2,−5⁢t+1,3⁢t+1
eval(alpha, t = 0);
2,1,1
eval(diff(alpha, t), t = 0);
2,−5,3
beta := expand(ApplyTransformation(phi, alpha));
β ≔ −t2−2⁢t+3,−21⁢t2+18⁢t+3,−11⁢t2+6⁢t+5
A := eval(diff(beta, t), t = 0);
A ≔ −2,18,6
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).
ComponentFunctions := ApplyTransformation(phi, [x, y, z]);
ComponentFunctions ≔ y⁢x+z2,x2−y2,y⁢z+x2
F := map2(LieDerivative, X, CoordinateFunctions);
F ≔ 0
eval(F, [x = 2, y = 1, z = 1]);
Exercise 2
restart: with(DifferentialGeometry):
[i] Write the vector field X1 in polar coordinates r, theta.
DGsetup([x, y], E2):
DGsetup([r, theta], Polar):
X1 := evalDG((x^2 - y^2)*D_x + 2*x*y*D_y);
X1 ≔ x2−y2⁢D_x+2⁢x⁢y⁢D_y
[ii] Write the vector field X2 in spherical coordinates rho, theta, phi.
DGsetup([x, y, z], E3):
DGsetup([rho, theta, phi], Spherical):
X2 := evalDG(x*z*D_x + y*z*D_y + (-x^2 - y^2)*D_z);
X2 ≔ x⁢z⁢D_x+y⁢z⁢D_y+−x2−y2⁢D_z
P := Transformation(Polar, E2, [x = r*cos(theta), y = r*sin(theta)]);
P ≔ x=r⁢cos⁡θ,y=r⁢sin⁡θ
_EnvExplicit := true:
invP := InverseTransformation(P);
invP ≔ r=y2+x2,θ=arctan⁡yy2+x2,xy2+x2
Y1 := Pushforward(invP, P, X1);
Y1 ≔ r2⁢cos⁡θ⁢csgn⁡r⁢D_r+r⁢sin⁡θ⁢D_theta
map(simplify,Y1) assuming r > 0;
r2⁢cos⁡θ⁢D_r+r⁢sin⁡θ⁢D_theta
Part [ii]
S := Transformation(Spherical, E3, [x = rho*cos(theta)*sin(phi), y = rho*sin(theta)*sin(phi), z = rho*cos(phi)]);
S ≔ x=ρ⁢cos⁡θ⁢sin⁡φ,y=ρ⁢sin⁡θ⁢sin⁡φ,z=ρ⁢cos⁡φ
invS := InverseTransformation(S);
invS ≔ ρ=y2+x2+z2,θ=arctan⁡y⁢y2+x2+z2y2+x2+z2⁢y2+x2,x⁢y2+x2+z2y2+x2+z2⁢y2+x2,φ=arctan⁡y2+x2+z2⁢y2+x2y2+x2+z2,zy2+x2+z2
Y2 := Pushforward(invS, S, X2);
Y2 ≔ −csgn⁡ρ⁢ρ3⁢−1+cos⁡φ2⁢D_phiρ4⁢sin⁡φ2
map(simplify, Y2) assuming rho >0, phi > 0, phi < Pi;
ρ⁢sin⁡φ⁢D_phi
Exercise 3
Find, if possible, all vector fields X which pushforwards by phi to the vector field Y.
phi := Transformation(N, M, [x = v*cos(u), y = v*sin(u), z = v^2]);
φ ≔ x=v⁢cos⁡u,y=v⁢sin⁡u,z=v2
[i]
Y1 := eval(x*D_y);
Y1 ≔ x⁢D_y
[ii]
Y2 := eval(x*D_x + y*D_y + 2*z*D_z);
Y2 ≔ x⁢D_x+y⁢D_y+2⁢z⁢D_z
X := PullbackVector(phi, Y1, [D_u, D_v]);
X ≔
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.
X := PullbackVector(phi, Y2, [D_u, D_v]);
X ≔ v⁢D_v
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)]
LieBracketNaturality := proc(phi, X, Y)
local TF, invPhi, a1, a, b1, b2, b, c;
TF := _EnvExplicit;
invPhi := InverseTransformation(phi);
_EnvExplicit := TF;
a1 := LieBracket(X, Y);
a := Pushforward(phi, invPhi, a1);
b1 := Pushforward(phi, invPhi, X);
b2 := Pushforward(phi, invPhi, Y);
c := LieBracket(b1, b2);
simplify(a &minus c);
end:
Test the program LieBracketNaturality
phi := Transformation(M, M, [x = x*y*z, y = y*z, z = 1/z]);
φ ≔ x=x⁢y⁢z,y=y⁢z,z=1z
X := evalDG(sin(x*z)*D_x + log(y + z)*D_y + (1/(x + y))*D_z);
X ≔ sin⁡x⁢z⁢D_x+ln⁡y+z⁢D_y+D_zx+y
Y := evalDG(exp(y)*x*D_x - arctan(x/z)*D_z);
Y ≔ ⅇy⁢x⁢D_x−arctan⁡xz⁢D_z
LieBracketNaturality(phi, X, Y);
Exercise 5
DGsetup([x, y], M):
Calculate the Lie bracket of the vector fields X and Y from their flows.
X := evalDG(x^2*D_x + x*y*D_y);
X ≔ x2⁢D_x+x⁢y⁢D_y
Y := evalDG(-x*y*D_x + y^2*D_y);
Y ≔ −x⁢y⁢D_x+y2⁢D_y
Calculate the Lie bracket directly.
LieBracket(X, Y);
2⁢x⁢y2⁢D_y
Calculate the flow of X.
phi := simplify(Flow(X, t));
φ ≔ x=−xt⁢x−1,y=−yt⁢x−1
phi1 := eval(phi, t = -t);
φ1 ≔ x=−x−t⁢x−1,y=−y−t⁢x−1
Calculate the flow of Y.
psi := simplify(Flow(Y, t));
ψ ≔ x=−x⁢t⁢y−1,y=−yt⁢y−1
psi1 := eval(psi, t = -t);
ψ1 ≔ x=−x⁢−t⁢y−1,y=−y−t⁢y−1
Phi := simplify(ComposeTransformations(psi1, phi1, psi, phi));
Φ ≔ x=x⁢2⁢t3⁢y⁢x2−2⁢t2⁢x⁢y+t3⁢y2⁢x+t2⁢x2−2⁢t⁢x+1t2⁢x⁢y+t⁢x−12,y=t⁢x−12⁢y2⁢t3⁢y⁢x2−2⁢t2⁢x⁢y+t3⁢y2⁢x+t2⁢x2−2⁢t⁢x+1
C := eval(ApplyTransformation(Phi, [x, y]), t = sqrt(s)):
Z := map(limit, diff(C, s), s = 0);
Z ≔ 0,2⁢x⁢y2
Exercise 6
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}.
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);
X1 ≔ x⁢D_xx+y+u+y⁢D_yx+y+u+z⁢D_zx+y+u+u⁢D_ux+y+u+v⁢D_vx+y+u
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);
X2 ≔ −u⁢x⁢D_xx+y+u+u⁢x+u⁢D_yx+y+u−u⁢z⁢D_zx+y+u−u2⁢D_ux+y+u−u⁢v⁢D_vx+y+u
X3 := evalDG(u*D_z);
X3 ≔ u⁢D_z
DGsetup([u1, u2, u3, u4, u5], N):
Calculate the flow of X1, X2, and X3.
phi1 := simplify(Flow(X1, u1));
φ1 ≔ x=x⁢u1+x+y+ux+y+u,y=y⁢u1+x+y+ux+y+u,z=z⁢u1+x+y+ux+y+u,u=u⁢u1+x+y+ux+y+u,v=v⁢u1+x+y+ux+y+u
phi2 := simplify(Flow(X2, u2));
φ2 ≔ x=x⁢x+y+uu2⁢u+x+y+u,y=x+y+u⁢u2⁢u+yu2⁢u+x+y+u,z=z⁢x+y+uu2⁢u+x+y+u,u=x+y+u⁢uu2⁢u+x+y+u,v=v⁢x+y+uu2⁢u+x+y+u
phi3 := simplify(Flow(X3, u3));
φ3 ≔ x=x,y=y,z=u⁢u3+z,u=u,v=v
Compose these 3 flows.
A := ComposeTransformations(phi3, phi2, phi1):
Apply the combined flow to the points [1, 0, 0, u4, u5].
B := simplify(ApplyTransformation(A, [1, 0, 0, u4, u5]));
B ≔ u1+1+u4u2⁢u4+1+u4,u2⁢u4⁢u1+1+u4u2⁢u4+1+u4,u4⁢u1+1+u4⁢u3u2⁢u4+1+u4,u4⁢u1+1+u4u2⁢u4+1+u4,u1+1+u4⁢u5u2⁢u4+1+u4
vars := [x, y, z, u, v]:
F := Transformation(N, M, [seq(vars[i] = B[i], i = 1 .. 5)]);
F ≔ x=u1+1+u4u2⁢u4+1+u4,y=u2⁢u4⁢u1+1+u4u2⁢u4+1+u4,z=u4⁢u1+1+u4⁢u3u2⁢u4+1+u4,u=u4⁢u1+1+u4u2⁢u4+1+u4,v=u1+1+u4⁢u5u2⁢u4+1+u4
Check that the change of variables defined by F does indeed straighten out the vectors X1, X2, X3.
invF := InverseTransformation(F, "all");
invF ≔ u1=x⁢y+x2+x⁢u−x−ux,u2=yu,u3=zu,u4=ux,u5=vx
Pushforward(invF, F, X1), Pushforward(invF, F, X2), Pushforward(invF, F, X3);
D_u1,D_u2,D_u3
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.
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):
A := Matrix([[exp(-x1), -x1*exp(-x1), x2], [0, exp(-x1), x3], [0, 0, 1]]);
XL := [D_x1, exp(-x1)*D_x2, -x1*exp(-x1)*D_x2 + exp(-x1)*D_x3];
XL ≔ D_x1,ⅇ−x1⁢D_x2,−x1⁢ⅇ−x1⁢D_x2+ⅇ−x1⁢D_x3
XR := [D_x1 + (-x3 - x2)*D_x2 - x3*D_x3, D_x2, D_x3];
XR ≔ D_x1+−x3−x2⁢D_x2−x3⁢D_x3,D_x2,D_x3
[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].
MultiplicationRule := [z3 = (y3 + x3*exp(x1))/exp(x1), z2 = (y2 - x1*y3 + x2*exp(x1))/exp(x1), z1 = x1 + y1];
MultiplicationRule ≔ z3=y3+x3⁢ⅇx1ⅇx1,z2=y2−x1⁢y3+x2⁢ⅇx1ⅇx1,z1=x1+y1
Part [i] Define right multiplication by [a1, a2, a3].
mult := eval(MultiplicationRule, [y1 = a1, y2 = a2, y3 = a3, z1 = x1, z2 = x2, z3 = x3]):
RightMult := Transformation(G, G, mult);
RightMult ≔ x1=x1+a1,x2=a2−x1⁢a3+x2⁢ⅇx1ⅇx1,x3=a3+x3⁢ⅇx1ⅇx1
Define left multiplication by [a1, a2, a3].
mult := eval(MultiplicationRule, [x1 = a1, x2 = a2, x3 = a3, z1 = x1, z2 = x2, z3 = x3]):
mult := eval(mult, [y1 = x1, y2 = x2, y3 = x3]):
LeftMult := Transformation(G, G, mult);
LeftMult ≔ x1=x1+a1,x2=x2−a1⁢x3+a2⁢ⅇa1ⅇa1,x3=x3+a3⁢ⅇa1ⅇa1
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.
pushXL := map2(Pushforward, LeftMult, XL);
pushXL ≔ D_x1,ⅇ−x1−a1⁢D_x2,−ⅇ−x1−a1⁢x1+a1⁢D_x2+ⅇ−x1−a1⁢D_x3
p := ApplyTransformation(LeftMult, [x1 = x1, x1 = x1, x1 = x1]);
p ≔ x1=x1+a1,x2=x2−a1⁢x3+a2⁢ⅇa1ⅇa1,x3=x3+a3⁢ⅇa1ⅇa1
evalXL := eval(XL, p);
evalXL ≔ D_x1,ⅇ−x1−a1⁢D_x2,−x1+a1⁢ⅇ−x1−a1⁢D_x2+ⅇ−x1−a1⁢D_x3
seq(pushXL[i] &minus evalXL[i], i = 1 .. 3);
0⁢D_x1,0⁢D_x1,0⁢D_x1
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.
pushXR := map2(Pushforward, RightMult, XR);
pushXR ≔ D_x1+−x3−x2−ⅇ−x1⁢a3−ⅇ−x1⁢a2+ⅇ−x1⁢x1⁢a3⁢D_x2+−x3−ⅇ−x1⁢a3⁢D_x3,D_x2,D_x3
p := ApplyTransformation(RightMult, [x1 = x1, x1 = x1, x1 = x1]);
p ≔ x1=x1+a1,x2=a2−x1⁢a3+x2⁢ⅇx1ⅇx1,x3=a3+x3⁢ⅇx1ⅇx1
evalXR := eval(XR, p);
evalXR ≔ D_x1+−a3+x3⁢ⅇx1ⅇx1−a2−x1⁢a3+x2⁢ⅇx1ⅇx1⁢D_x2−a3+x3⁢ⅇx1⁢D_x3ⅇx1,D_x2,D_x3
seq(pushXR[i] &minus evalXR[i], i = 1 .. 3);
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.
XL1 := map2(Pushforward, LeftMult, [D_x1, D_x2, D_x3], [x1 = 0, x2 = 0, x3 = 0]);
XL1 ≔ D_x1,ⅇ−a1⁢D_x2,−a1⁢ⅇ−a1⁢D_x2+ⅇ−a1⁢D_x3
Replace [a1, a2, a3] by [x1, x2, x3] to obtain the left invariant vector fields.
XL2 := eval(XL1, [a1 = x1, a2 = x2, a3 = x3]);
XL2 ≔ D_x1,ⅇ−x1⁢D_x2,−x1⁢ⅇ−x1⁢D_x2+ⅇ−x1⁢D_x3
XR1 := map2(Pushforward, RightMult, [D_x1, D_x2, D_x3], [x1 = 0, x2 = 0, x3 = 0]);
XR1 ≔ D_x1+−a3−a2⁢D_x2−a3⁢D_x3,D_x2,D_x3
Replace [a1, a2, a3] by [x1, x2, x3] to obtain the right invariant vector fields.
XR2 := eval(XR1, [a1 = x1, a2 = x2, a3 = x3]);
XR2 ≔ D_x1+−x3−x2⁢D_x2−x3⁢D_x3,D_x2,D_x3
Download Help Document