DGinfo - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim


DifferentialGeometry[Tools]

  

DGinfo

  

obtain information about  DifferentialGeometry objects

 

Calling Sequence

Parameters

Description

Function, Vector, DifferentialForm, and Tensor Information

Transformation Information

Frame Information

Miscellaneous

Calling Sequence

DGinfo(X, keyword)

Parameters

X

-

a DifferentialGeometry object

keyword

-

a keyword string

Description

• 

The command DGinfo provides a user friendly interface to the internal representations of all the objects and frames created by the DifferentialGeometry software.

• 

The keyword strings accepted by the DGinfo command are:

AbstractForms

BiformDegree

CoefficientGrading

CoefficientList

CoefficientSet

CoframeLabels

CurrentFrame

DiffeqType

DiffeqVariables

DomainFrame

DomainOrder

ExteriorDerivativeFormStructureEquations

ExteriorDerivativeFunctionStructureEquations

FormDegree

FrameBaseDimension

FrameBaseForms

FrameBaseVectors

FrameDependentVariables

FrameFiberDimension

FrameFiberForms

FrameFiberVectors

FrameGlobals

FrameHorizontalBiforms

FrameIndependentVariables

FrameInformation

FrameJetDimension

FrameJetForms

FrameJetOrder

FrameJetVariables

FrameJetVectors

FrameLabels

FrameNames

FrameProtocol

FrameVerticalBiforms

FunctionOrder

Grading

HorizontalCoframeLabels

JacobianMatrix

JetIndets

JetNotation

JetSpaceDimension

Keywords

LieAlgebraDimension

LieBracketStructureEquations

LieBracketStructureFunction

LieBracketStructureFunctionList

LieDerivativeFunctionStructureEquations

NonJetIndets

ObjectAttributes

ObjectComponents

ObjectFrame

ObjectGenerators

ObjectOrder

ObjectType

RangeFrame

RangeOrder

RepresentationMatrices

TensorDensityType

TensorGenerators

TensorIndexPart1

TensorIndexPart2

TensorIndexType

TensorType

TransformationType

VectorType

VerticalCoframeLabels

Weight

 

 

• 

This command is part of the DifferentialGeometry:-Tools package and so can be used in the form DGinfo(...) only after executing the commands with(DifferentialGeometry) and with(Tools) in that order.  It can always be used in the long form DifferentialGeometry:-Tools:-DGinfo(...).

Function, Vector, DifferentialForm, and Tensor Information

"BiformDegree"

with(DifferentialGeometry): with(Tools):

DGsetup([x, y], [u], E, 2):

 

Example 1.

alpha1 := evalDG(Dx &wedge Dy);

α1DxDy

(1)

DGinfo(alpha1, "BiformDegree");

2,0

(2)

Example 2.

alpha2 := evalDG(Dx &wedge Cu[]);

α2DxCu

(3)

DGinfo(alpha2, "BiformDegree");

1,1

(4)

Example 3.

alpha3 := evalDG(Cu[1] &wedge Cu[2]);

α3Cu1Cu2

(5)

DGinfo(alpha3, "BiformDegree");

0,2

(6)

"CoefficientList": list some or all of the coefficients of a vector, differential form, or tensor.

with(DifferentialGeometry): with(Tools):

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

alpha := evalDG(a*dx &w dy + b*dx &w dz + c*dy &w dz + d*dx &w dw + e*dz &w dw);

αadxdy+bdxdz+ddxdw+cdydz+edzdw

(7)

DGinfo(alpha, "CoefficientList", "all");

a,b,d,c,e

(8)

DGinfo(alpha, "CoefficientList", [dx &w dy, dx &w dz, dy &w dw]);

a,b,0

(9)

DGinfo(alpha, "CoefficientList", [[1,2], [1,3], [2,4]]);

a,b,0

(10)

"CoefficientSet": find the set of all the coefficients of a vector, differential form, or tensor.

with(DifferentialGeometry): with(Tools):

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

 

Example 1.

alpha := evalDG(a*dx &w dy + b*dx &w dz + b*dy &w dz + c*dx &w dw + a*dz &w dw);

αadxdy+bdxdz+cdxdw+bdydz+adzdw

(11)

DGinfo(alpha, "CoefficientSet");

a,b,c

(12)

Example 2.

X := DGzero("vector");

X0D_x

(13)

DGinfo(X, "CoefficientSet");

0

(14)

"CoefficientList": list some or all of the coefficients of a vector, differential form, or tensor.

with(DifferentialGeometry): with(Tools):

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

alpha := evalDG(a*dx &w dy + b*dx &w dz + c*dy &w dz + d*dx &w dw + e*dz &w dw);

αadxdy+bdxdz+ddxdw+cdydz+edzdw

(15)

DGinfo(alpha, "CoefficientList", "all");

a,b,d,c,e

(16)

DGinfo(alpha, "CoefficientList", [dx &w dy, dx &w dz, dy &w dw]);

a,b,0

(17)

DGinfo(alpha, "CoefficientList", [[1,2], [1,3], [2,4]]);

a,b,0

(18)

"DiffeqType": find the type of the system of differential equations

with(DifferentialGeometry): with(JetCalculus): with(Tools):

DGsetup([x, y], [u, v], E, 2):

Delta := DifferentialEquationData([u[2] + v[1], u[1] - v[2]], [u[1], v[1]]);

Δu1,v1,u2+v1,u1v2

(19)

DGinfo(Delta, "DiffeqType");

evolutionary,0

(20)

"DiffeqVariables": list the jet variables in the differential equation to be solved for

with(DifferentialGeometry): with(JetCalculus): with(Tools):

DGsetup([x, y], [u, v], E, 2):

Delta := DifferentialEquationData([u[2] + v[1], u[1] - v[2]], [u[1], v[1]]);

Δu1,v1,u2+v1,u1v2

(21)

DGinfo(Delta, "DiffeqVariables");

u1,v1

(22)

"FormDegree": the degree of a differential form

with(DifferentialGeometry): with(Tools):

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

 

Example 1.

alpha := evalDG(dx +dy);

αdx+dy

(23)

DGinfo(alpha, "FormDegree");

1

(24)

Example 2.

beta := evalDG(3*dx &w dy + 4*dy &w dz - dx &w dz);

β3dxdydxdz+4dydz

(25)

DGinfo(beta, "FormDegree");

2

(26)

Example 3.

nu := evalDG(dx &w dy &w dz);

νdxdydz

(27)

DGinfo(nu, "FormDegree");

3

(28)

"FunctionOrder": the order of the highest jet coordinate appearing in a Maple expression.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

f1 := u*x + v*y;

f1ux+vy

(29)

DGinfo(f1, "FunctionOrder");

0

(30)

Example 2.

DGsetup([x, y], [u], J, 1):

f1 := u[1]*x + u[2];

f1u1x+u2

(31)

DGinfo(f1, "FunctionOrder");

1

(32)

Example 3.

f1 := u[1, 1, 2]*x + u[2, 2, 2, 2];

f1u1,1,2x+u2,2,2,2

(33)

DGinfo(f1, "FunctionOrder");

4

(34)

"ObjectAttributes": list all the properties of a vector, differential form, tensor, or transformation.

with(DifferentialGeometry): with(Tools):

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

 

Example 1.

X := evalDG(a*D_x + b*D_y + c*D_z);

XaD_x+bD_y+cD_z

(35)

DGinfo(X, "ObjectAttributes");

vector,M,

(36)

Example 2.

alpha := evalDG(d*dx &w dy + e*dx &w dz + f*dy &w dz);

αddxdy+edxdz+fdydz

(37)

DGinfo(alpha, "ObjectAttributes");

form,M,2

(38)

Example 3.

T := evalDG(r*D_x &t dx + s*D_z&t dy + t*D_z &t dx);

TrD_xdx+tD_zdx+sD_zdy

(39)

DGinfo(T, "ObjectAttributes");

tensor,M,con_bas,cov_bas,

(40)

Example 4.

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

Φu=x2+y2+z2,v=xyz

(41)

DGinfo(Phi, "ObjectAttributes");

transformation,M,0,N,0,,2x2y2zyzxzxy

(42)

Example 5.

DGsetup([[gamma1, gamma2, gamma3, gamma4], chi = dgform(3)], [], P):

ExteriorDerivative(chi);

dχ

(43)

DGinfo(dchi, "ObjectAttributes");

form,P,4,d,5

(44)

Example 6.

Hook(D_gamma1, chi);

ι1χ

(45)

DGinfo(i_1chi, "ObjectAttributes");

form,P,2,hook,1,5

(46)

Example 7.

Hook([D_gamma2, D_gamma3], chi);

ι2,3χ

(47)

DGinfo(i_2_3chi, "ObjectAttributes");

form,P,1,hook,2,3,5

(48)

"ObjectComponents": list all the components of a vector, differential form, tensor, or transformation.

with(DifferentialGeometry): with(Tools):

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

 

Example 1.

X := evalDG(a*D_x + b*D_y + c*D_z);

XaD_x+bD_y+cD_z

(49)

DGinfo(X, "ObjectComponents");

1,a,2,b,3,c

(50)

Example 2.

alpha := evalDG(d*dx &w dy + e*dx &w dz + f*dy &w dz);

αddxdy+edxdz+fdydz

(51)

DGinfo(alpha, "ObjectComponents");

1,2,d,1,3,e,2,3,f

(52)

Example 3.

T := evalDG(r*D_x &t dx + s*D_z&t dy + t*D_z &t dx);

TrD_xdx+tD_zdx+sD_zdy

(53)

DGinfo(T, "ObjectComponents");

1,1,r,3,1,t,3,2,s

(54)

Example 4.

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

Φu=x2+y2+z2,v=xyz

(55)

DGinfo(Phi, "ObjectComponents");

x2+y2+z2,u,xyz,v

(56)

"ObjectFrame": return the frame with respect to which the object is defined.

with(DifferentialGeometry): with(Tools):

DGsetup([x, y], [u], M, 1): DGsetup([r,s,t], N):

Example 1.

X := evalDG(D_x -3*D_y);

XD_x3D_y

(57)

DGinfo(X, "ObjectFrame");

M

(58)

Example 2.

T := evalDG(D_r &t D_s &t dt);

TD_rD_sdt

(59)

DGinfo(T, "ObjectFrame");

N

(60)

"ObjectGenerators": list the monomial vectors in a vector or the monomial 1-forms in a differential form.

with(DifferentialGeometry): with(Tools):

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

Example 1.

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

XyD_x+zD_z

(61)

DGinfo(X, "ObjectGenerators");

1,3

(62)

This means that X has only the 1st and 3rd elements from the standard basis for the tangent bundle.

Example 2.

alpha := evalDG(w*dx &w dy + x*dx &w dw + z^2*dy &w dw);

αwdxdy+xdxdw+z2dydw

(63)

DGinfo(alpha, "ObjectGenerators");

1,2,4

(64)

This means that alpha do not contain the 3rd element (dz) from the standard basis for the cotangent bundle.

"ObjectOrder": the order of the jet space on which the object is defined.

with(DifferentialGeometry): with(JetCalculus): with(Tools):

 

Example 1.

DGsetup([x, y], [u, v], E, 3):

f := u[2]*x + v[]*y;

fu2x+vy

(65)

DGinfo(f, "ObjectOrder");

1

(66)

Example 2.

alpha := evalDG(du[1]*x + du[2,2]);

αxdu1+du2,2

(67)

DGinfo(alpha, "ObjectOrder");

2

(68)

Example 3.

beta := evalDG(du[1, 1, 2]*x + u[2, 2, 2, 2]*dy);

βu2,2,2,2dy+xdu1,1,2

(69)

DGinfo(beta, "FunctionOrder");

4

(70)

Example 4.

X := evalDG(u[1]*D_u[]);

Xu1D_u

(71)

X3 := Prolong(X, 2);

X3u1D_u+u1,1D_u1+u1,2D_u2+u1,1,1D_u1,1+u1,1,2D_u1,2+u1,2,2D_u2,2

(72)

DGinfo(X3, "FunctionOrder");

3

(73)

"ObjectType": the type of the DifferentialGeometry object.

with(DifferentialGeometry): with(Tools): with(LieAlgebras):

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

 

Example 1.

f := sin(x)*cos(y);

fsinxcosy

(74)

DGinfo(f, "ObjectType");

DGscalar

(75)

Example 2.

X := evalDG(D_x + y*D_u[]);

XD_x+yD_u

(76)

DGinfo(X, "ObjectType");

vector

(77)

Example 3.

alpha := evalDG(dx &w dy + dx &w du[1]);

αdxdy+dxdu1

(78)

DGinfo(alpha, "ObjectType");

form

(79)

Example 4.

theta := evalDG(Dx &w Cu[1]);

θDxCu1

(80)

DGinfo(theta, "ObjectType");

biform

(81)

Example 5.

T := evalDG(dx &t D_y + dy &t D_y);

TdxD_y+dyD_y

(82)

DGinfo(T, "ObjectType");

tensor

(83)

Example 6.

A := Vector([1, 2]);

A12

(84)

DGinfo(A, "ObjectType");

Vector

(85)

Example 7.

B := Matrix([1, 2]);

B12

(86)

DGinfo(B, "ObjectType");

Matrix

(87)

Example 8.

B:= Matrix([[1, 2], [3, 4]]);

B1234

(88)

DGinfo(B, "ObjectType");

Matrix

(89)

Example 9.

Phi := IdentityTransformation();

Φx=x,y=y,u=u

(90)

DGinfo(Phi, "ObjectType");

transformation

(91)

Example 10.

L := LieAlgebraData(evalDG([D_x, x*D_x, x^2*D_x]));

Le1,e2=e1,e1,e3=2e2,e2,e3=e3

(92)

DGinfo(L, "ObjectType");

LieAlgebra

(93)

Example 11.

DGsetup([x, y], M);

frame name: M

(94)

F := FrameData([y*dx, x*dy], N);

FdΘ1=Θ1Θ2yx,dΘ2=Θ1Θ2yx

(95)

DGinfo(F, "ObjectType");

moving_frame

(96)

Example 12.

DGsetup([x, y], V);

frame name: V

(97)

R := [Matrix([[1, 0], [0, 0]]), Matrix([[0, 1], [0, 0]]), Matrix([[0, 0], [0, 1]])];

R1000,0100,0001

(98)

L := LieAlgebraData(R, Alg);

Le1,e2=e2,e2,e3=e2

(99)

DGsetup(L);

Lie algebra: Alg

(100)

rho := Representation(Alg, V, R);

ρe1,1000,e2,0100,e3,0001

(101)

DGinfo(rho, "ObjectType");

Representation

(102)

"TensorDensityType": the density weight of a tensor.

with(DifferentialGeometry): with(Tools): with(Tensor):

DGsetup([x, y],[u, v, w], E):

g := evalDG(dx &t dx + dy &t dy);

gdxdx+dydy

(103)

Example 1.

rho := MetricDensity(g, 3);

ρ1

(104)

T1 := D_x &tensor rho;

T1D_x

(105)

DGinfo(T1, "TensorDensityType");

bas,3

(106)

Example 2.

T2 := PermutationSymbol("cov_vrt");

T2dudvdwdudwdvdvdudw+dvdwdu+dwdudvdwdvdu

(107)

DGinfo(T2, "TensorDensityType");

vrt,−1

(108)

"TensorGenerators": a list of the monomial tensors which generate a given tensor.

with(DifferentialGeometry): with(Tools): with(Tensor):

DGsetup([x, y], [u, v, w], E):

 

Example 1.

T1 := evalDG(dx &t dx &t dx);

T1dxdxdx

(109)

DGinfo(T1, "TensorGenerators");

cov_bas,1

(110)

Example 2.

T2 := evalDG(dx &t D_y &t dy);

T2dxD_ydy

(111)

DGinfo(T2, "TensorGenerators");

con_bas,2,cov_bas,1,cov_bas,2

(112)

Example 3.

T3 := evalDG(du &t D_v &t dy);

T3duD_vdy

(113)

DGinfo(T3, "TensorGenerators");

con_vrt,4,cov_bas,2,cov_vrt,3

(114)

"TensorIndexPart1": the tensor character of a tensor index type.

with(DifferentialGeometry): with(Tools):

DGinfo("con_bas", "TensorIndexPart1");

con

(115)

DGinfo("cov_bas", "TensorIndexPart1");

cov

(116)

DGinfo("con_vrt", "TensorIndexPart1");

con

(117)

DGinfo("cov_vrt", "TensorIndexPart1");

cov

(118)

"TensorIndexPart2": the spatial type of a tensor index type.

with(DifferentialGeometry): with(Tools):

DGinfo("con_bas", "TensorIndexPart2");

bas

(119)

DGinfo("cov_bas", "TensorIndexPart2");

bas

(120)

DGinfo("con_vrt", "TensorIndexPart2");

vrt

(121)

DGinfo("cov_vrt", "TensorIndexPart2");

vrt

(122)

"TensorIndexType": the full tensor index type of a tensor.

with(DifferentialGeometry): with(Tools): with(Tensor):

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

Example 1.

T1 := evalDG(D_x &t D_y);

T1D_xD_y

(123)

DGinfo(T1, "TensorIndexType");

con_bas,con_bas

(124)

Example 2.

T2 := evalDG(dx &t D_y);

T2dxD_y

(125)

DGinfo(T2, "TensorIndexType");

cov_bas,con_bas

(126)

Example 3.

T3 := evalDG(du &t D_v);

T3duD_v

(127)

DGinfo(T3, "TensorIndexType");

cov_vrt,con_vrt

(128)

Example 4.

T4 := evalDG(D_x &t D_v);

T4D_xD_v

(129)

DGinfo(T4, "TensorIndexType");

con_bas,con_vrt

(130)

"TensorType": the full tensor index type and weight of a tensor.

with(DifferentialGeometry): with(Tools): with(Tensor):

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

 

Example 1.

T1 := evalDG(D_x &t D_y);

T1D_xD_y

(131)

DGinfo(T1, "TensorType");

con_bas,con_bas,

(132)

Example 2.

T2 := PermutationSymbol("con_bas");

T2D_xD_yD_yD_x

(133)

DGinfo(T2, "TensorType");

con_bas,con_bas,bas,1

(134)

Example 3.

T3 := evalDG(du &t D_v);

T3duD_v

(135)

DGinfo(T3, "TensorType");

cov_vrt,con_vrt,

(136)

Example 4.

T4 := PermutationSymbol("cov_vrt");

T4dudvdvdu

(137)

DGinfo(T4, "TensorType");

cov_vrt,cov_vrt,vrt,−1

(138)

Example 5.

T5 := PermutationSymbol("cov_bas") &tensor PermutationSymbol("con_vrt");

T5dxdyD_uD_vdxdyD_vD_udydxD_uD_v+dydxD_vD_u

(139)

DGinfo(T5, "TensorType");

cov_bas,cov_bas,con_vrt,con_vrt,bas,−1,vrt,1

(140)

"VectorType": the type (projectionable, point, contact, ...) of a vector field and its order of prolongation.  See AssignVectorType for details.

with(DifferentialGeometry): with(Tools): with(JetCalculus):

DGsetup([x,y], [u], E, 1):

Example 1.

X1 := evalDG(D_x + u[] *D_u[]);

X1D_x+uD_u

(141)

X1a := AssignVectorType(X1);

X1aD_x+uD_u

(142)

DGinfo(X1a, "VectorType");

projectable,0

(143)

Example 2.

X2 := Prolong(u[]*D_x - x *D_u[], 1);

X2uD_xxD_uu12+1D_u1u2u1D_u2

(144)

DGinfo(X2, "VectorType");

point,1

(145)

Example 3.

X3 := GeneratingFunctionToContactVector(u[]*u[1]*u[2]);

X3uu2D_xuu1D_yuu1u2D_u+u12u2D_u1+u22u1D_u2

(146)

X3a := AssignVectorType(X3);

X3auu2D_xuu1D_yuu1u2D_u+u12u2D_u1+u22u1D_u2

(147)

DGinfo(X3a, "VectorType");

contact,1

(148)

Weight": the weight of a monomial form in a graded Lie algebra with coefficients

with(DifferentialGeometry): with(Tools):

 

LD:=LieAlgebraData([[x3, x4] = e1, [x3, x5] = x2, [x4, x5] = x3], [x1,x2,x3,x4,x5], Alg, grading = [-3, -3, -2, -1, -1]);

LDe3,e5=e2,e4,e5=e3

(149)

DGsetup(LD):

DGsetup([w1, w2, w3, w4, w5], V, grading = [-3, -3, -2, -1, -1]):

rho:= Representation(Alg, V, Adjoint(Alg));

ρe1,0000000000000000000000000,e2,0000000000000000000000000,e3,0000000001000000000000000,e4,0000000000000010000000000,e5,0000000−100000−100000000000

(150)

DGsetup(Alg, rho, AlgV);

Lie algebra with coefficients: AlgV

(151)

Example 1.

alpha1 := evalDG(w3 *theta5);

α1w3θ5

(152)

DGinfo(alpha1, "Weight");

−1

(153)

Example 2.

alpha2 := evalDG(w3 * theta1 &w theta5);

α2w3θ1θ5

(154)

DGinfo(alpha2, "Weight");

2

(155)

Example 3.

alpha3 := evalDG(w1 * theta3 &w  &w theta4 &w theta5);

α3w1θ3θ4θ5

(156)

DGinfo(alpha3, "Weight");

1

(157)

Transformation Information

"DomainFrame": the domain frame of a transformation.

with(DifferentialGeometry): with(Tools):

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

Phi := Transformation(M, N, [ u =x*y, v= 1/x + 1/y]);

Φu=xy,v=1x+1y

(158)

DGinfo(Phi, "DomainFrame");

M

(159)

"DomainOrder": the jet space order of the domain of a transformation.

with(DifferentialGeometry): with(Tools):

DGsetup([x, y], M): DGsetup([u, v], N): DGsetup([t], [w], J, 1):

 

Example 1.

Phi1 := Transformation(M, N, [u =x*y, v= 1/x + 1/y]);

Φ1u=xy,v=1x+1y

(160)

DGinfo(Phi1, "DomainOrder");

0

(161)

Example 2.

Phi2 := Transformation(J, M, [x = w[1], y = w[1, 1]]);

Φ2x=w1,y=w1,1

(162)

DGinfo(Phi2, "DomainOrder");

2

(163)

"JacobianMatrix": the Jacobian Matrix of a transformation.

with(DifferentialGeometry): with(Tools):

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

 

Example 1.

Phi := Transformation(M, N, [u = x*y, v = 1/x + 1/y, w = x + y]);

Φu=xy,v=1x+1y,w=x+y

(164)

DGinfo(Phi, "JacobianMatrix");

yx1x21y211

(165)

"RangeFrame": the range frame of a transformation.

with(DifferentialGeometry): with(Tools):

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

Phi := Transformation(M, N, [u =x*y, v= 1/x + 1/y]);

Φu=xy,v=1x+1y

(166)

DGinfo(Phi, "RangeFrame");

N

(167)

"RangeOrder": the jet space order of the range of a transformation.

with(DifferentialGeometry): with(Tools):

DGsetup([x, y], M): DGsetup([u, v], N): DGsetup([t], [w], J, 1):

 

Example 1.

Phi1 := Transformation(M, N, [u =x*y, v= 1/x + 1/y]);

Φ1u=xy,v=1x+1y

(168)

DGinfo(Phi1, "RangeOrder");

0

(169)

Example 2.

Phi2 := Transformation(M, J, [t= x, w[]= y, w[1] = y^2]);

Φ2t=x,w=y,w1=y2

(170)

DGinfo(Phi2, "RangeOrder");

1

(171)

"RepresentationMatrices": the list of matrices defining a representation of a Lie Algebra

with(DifferentialGeometry): with(LieAlgebras): with(Tools):

 

DGsetup([x, y], V);

frame name: V

(172)

R := [Matrix([[1, 0], [0, 0]]), Matrix([[0, 1], [0, 0]]), Matrix([[0, 0], [0, 1]])];

R1000,0100,0001

(173)

L := LieAlgebraData(R, Alg);

Le1,e2=e2,e2,e3=e2

(174)

DGsetup(L);

Lie algebra: Alg

(175)

rho := Representation(Alg, V, R);

ρe1,1000,e2,0100,e3,0001

(176)

DGinfo(rho, "RepresentationMatrices");

1000,0100,0001

(177)

"TransformationType": the type (projectionable, point, contact, ...) of a transformation.  See AssignTransformationType for details.

with(DifferentialGeometry): with(Tools): with(JetCalculus):

DGsetup([x], [u], E, 1):

 

Example 1.

Phi1 := Transformation(E, E, [x = x^2, u[] = u[]*x]);

Φ1x=x2,u=ux

(178)

Phi1A := AssignTransformationType(Phi1);

Phi1Ax=x2,u=ux

(179)

DGinfo(Phi1A, "TransformationType");

projectable,0

(180)

Example 2.

Phi2 := Transformation(E, E, [x = u[], u[] = x]);

Φ2x=u,u=x

(181)

Phi2A := AssignTransformationType(Phi2);

Phi2Ax=u,u=x

(182)

DGinfo(Phi2A, "TransformationType");

point,0

(183)

Example 3.

Phi3 := Transformation(E, E, [x = -2*u[1] + x, u[] = -u[1]^2 + u[], u[1] = u[1]]);

Φ3x=2u1+x,u=u12+u,u1=u1

(184)

Phi3A := AssignTransformationType(Phi3);

Phi3Ax=2u1+x,u=u12+u,u1=u1

(185)

DGinfo(Phi3A, "TransformationType");

contact,1

(186)

Frame Information

"AbstractForms": the list of forms defined in an abstract frame.

with(DifferentialGeometry): with(Tools):

 

DGsetup([[sigma1, sigma2, sigma3], tau = dgform(2), xi = dgform(3)], [], P):

 

Example 1.

DGinfo(P, "AbstractForms");

σ1,σ2,σ3,τ,ξ

(187)

Example 2.

ExteriorDerivative(tau);

dτ

(188)

DGinfo(P, "AbstractForms");

σ1,σ2,σ3,τ,ξ,dτ

(189)

Example 3.

Hook(D_sigma1, xi);

ι1ξ

(190)

Hook([D_sigma2, D_sigma3], xi);

ι2,3ξ

(191)

DGinfo(P, "AbstractForms");

σ1,σ2,σ3,τ,ξ,dτ,ι1ξ,ι2ξ,ι2,3ξ

(192)

"CoefficientGrading": the grading of the coefficients in a Lie algebra with coefficients

with(DifferentialGeometry): with(LieAlgebras): with(Tools):

 

Example 1.

LD:=LieAlgebraData([[x3, x4] = e1, [x3, x5] = x2, [x4, x5] = x3], [x1,x2,x3,x4,x5], Alg, grading = [-3, -3, -2, -1, -1]);

LDe3,e5=e2,e4,e5=e3

(193)

DGsetup(LD):

DGsetup([w1, w2, w3, w4, w5], V, grading = [-3, -3, -2, -1, -1]):

rho:= Representation(Alg, V, Adjoint(Alg));

ρe1,0000000000000000000000000,e2,0000000000000000000000000,e3,0000000001000000000000000,e4,0000000000000010000000000,e5,0000000−100000−100000000000

(194)

DGsetup(Alg, rho, AlgV):

DGinfo(AlgV, "CoefficientGrading");

tablew2=−3,w5=−1,w3=−2,w4=−1,w1=−3

(195)

DGinfo(AlgV, "CoefficientGrading", output = "list");

−3,−3,−2,−1,−1

(196)

DGinfo(output = "coefficients", "CoefficientGrading");

w1−3,w2−3,w3−2,w4−1,w5−1

(197)

"CoframeLabels": list the labels used to input and display the basis of 1-forms for the cotangent space.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "CoframeLabels");

dx,,dy,,dz,

(198)

Example 2.

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

F := FrameData([y*dx, z*dy, dz], N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(199)

DGsetup(F, [X], [omega]):

DGinfo(N, "CoframeLabels");

omega1,,omega2,,omega3,

(200)

Example 3.

DGsetup([x, y], [u], E, 2):

DGinfo(E, "CoframeLabels");

dx,,dy,,du,,du,1,du,2,du,1,1,du,1,2,du,2,2

(201)

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(202)

DGsetup(L1):

DGinfo(Alg1, "CoframeLabels");

theta1,,theta2,,theta3,,theta4,

(203)

"CurrentFrame": the name of the currently active frame.

with(DifferentialGeometry): with(Tools):

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

DGinfo("CurrentFrame");

N

(204)

LieBracket(D_x, x*D_x);

D_x

(205)

DGinfo("CurrentFrame");

M

(206)

"ExteriorDerivativeFormStructureEquations": list the formulas for the exterior derivatives of a frame with protocol "LieAlgebra" or "AnholonomicFrame".

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo("ExteriorDerivativeFormStructureEquations");

(207)

Example 2.

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

F := FrameData([y*dx, z*dy, dz], N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(208)

DGsetup(F, [X], [omega]):

DGinfo(N, "ExteriorDerivativeFormStructureEquations");

ω1yzω2,ω2zω3,0ω1ω2

(209)

Example 3.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(210)

DGsetup(L1):

DGinfo(Alg1, "ExteriorDerivativeFormStructureEquations");

θ2θ4,0θ1θ2,θ3θ4,0θ1θ2

(211)

"ExteriorDerivativeFunctionStructureEquations": list the formulas for the exterior derivatives of the coordinate functions for a frame with protocol or "moving_frame".

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo("ExteriorDerivativeFunctionStructureEquations");

(212)

Example 2.

DGsetup([x, y, z], M):
F := FrameData([y*dx, z*dy, dz], N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(213)

DGsetup(F, [X], [omega]):

DGinfo(N, "ExteriorDerivativeFunctionStructureEquations");

ω1y,ω2z,ω3

(214)

Example 3.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(215)

DGsetup(L1):

DGinfo(Alg1, "ExteriorDerivativeFunctionStructureEquations");

(216)

"FrameBaseDimension": the dimension of the base manifold M for a frame defining a bundle E -> M; the dimension of M for a frame defining a manifold M; the dimension of the Lie algebra for a frame defining a Lie algebra.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameBaseDimension");

3

(217)

 

Example 2.

DGsetup([x, y], [u, v, w], E):

DGinfo(E, "FrameBaseDimension");

2

(218)

Example 3.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(219)

DGsetup(L1):

DGinfo(Alg1, "FrameBaseDimension");

4

(220)

"FrameBaseForms": the basis 1-forms for the cotangent space of the base manifold M for a frame defining a bundle E -> M; the basis 1-forms for the cotangent space M for a frame defining a manifold M; the dual 1-forms of a Lie algebra for a frame defining a Lie algebra.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameBaseForms");

dx,dy,dz

(221)

 

Example 2.

DGsetup([x, y, z], M):
F := FrameData([y*dx, z*dy, dz], N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(222)

DGsetup(F, [X], [omega]):

DGinfo(N, "FrameBaseForms");

ω1,ω2,ω3

(223)

 

Example 3.

DGsetup([x, y], [u], E, 2):

DGinfo(E, "FrameBaseForms");

dx,dy

(224)

 

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(225)

DGsetup(L1):

DGinfo(Alg1, "FrameBaseForms");

θ1,θ2,θ3,θ4

(226)

"FrameBaseVectors": the basis vectors for the tangent space of the base manifold M for a frame defining a bundle E -> M; the basis vectors for the tangent space M for a frame defining a manifold M; the basis vectors of a Lie algebra for a frame defining a Lie algebra.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameBaseVectors");

D_x,D_y,D_z

(227)

Example 2.

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

F := FrameData([y*dx, z*dy, dz], N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(228)

DGsetup(F, [W], [omega]):

DGinfo(N, "FrameBaseVectors");

W1,W2,W3

(229)

Example 3.

DGsetup([x, y], [u], E, 2):

DGinfo(E, "FrameBaseVectors");

D_x,D_y

(230)

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(231)

DGsetup(L1):

DGinfo(Alg1, "FrameBaseVectors");

e1,e2,e3,e4

(232)

"FrameDependentVariables": the dependent or fiber variables for a frame defining a bundle E -> M.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameDependentVariables");

(233)

Example 2.

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

DGinfo(M, "FrameDependentVariables");

(234)

Example 3.

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

DGinfo(M, "FrameDependentVariables");

(235)

"FrameFiberDimension": the dimension of the fiber for a frame defining a bundle E -> M.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameFiberDimension");

0

(236)

 

Example 2.

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

DGinfo(E, "FrameFiberDimension");

2

(237)

 

Example 3.

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

DGinfo(J, "FrameFiberDimension");

2

(238)

"FrameFiberForms": the coordinate basis of vertical 1-forms for a fiber bundle E -> M.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameFiberForms");

(239)

Example 2

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

DGinfo(E, "FrameFiberForms");

du,dv

(240)

Example 3

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

DGinfo(J, "FrameFiberForms");

du,dv

(241)

"FrameFiberVectors": the coordinate basis of vertical vectors for a fiber bundle E -> M.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameFiberVectors");

(242)

Example 2.

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

DGinfo(E, "FrameFiberVectors");

D_u,D_v

(243)

Example 3.

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

DGinfo(J, "FrameFiberVectors");

D_u,D_v

(244)

"FrameGlobals": the list of Maple names that are assigned or protected when a frame is defined using the DGsetup command.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameGlobals");

M,x,y,z,dx,dy,dz,D_x,D_y,D_z

(245)

Example 2.

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

F := FrameData([y*dx, z*dy, dz],N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(246)

DGsetup(F, [W], [omega]):

DGinfo(N, "FrameGlobals");

N,x,y,z,ω1,ω2,ω3,W1,W2,W3

(247)

Example 3.

DGsetup([x, y], [u], E, 2):

DGinfo(E, "FrameGlobals");

E,x,y,u,u1,u2,u1,1,u1,2,u2,2,Cu,Cu1,Cu2,Cu1,1,Cu1,2,Cu2,2,Dx,Dy,dx,dy,du,du1,du2,du1,1,du1,2,du2,2,D_x,D_y,D_u,D_u1,D_u2,D_u1,1,D_u1,2,D_u2,2

(248)

 

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(249)

DGsetup(L1):

DGinfo(Alg1, "FrameGlobals");

Alg1,_z14,_z15,_z16,_z17,θ1,θ2,θ3,θ4,e1,e2,e3,e4

(250)

"FrameHorizontalBiforms": the list of horizontal biforms on a jet space

with(DifferentialGeometry): with(Tools):

Example 1.

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

DGinfo(M, "FrameHorizontalBiforms");

(251)

 

Example 2.

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

DGinfo(J, "FrameHorizontalBiforms");

Dx,Dy,Dz

(252)

"FrameIndependentVariables": the coordinate variables of the base manifold M for a frame defining a bundle E -> M; the coordinate variables of M for a frame defining a manifold M; the internally defining coordinate variables of the Lie algebra for a frame defining a Lie algebra.

with(DifferentialGeometry): with(Tools):

Example 1.

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

DGinfo(M, "FrameIndependentVariables");

x,y,z

(253)

 

Example 2.

Omega := evalDG([y*dx, z*dy, dz]);

Ωydx,zdy,dz

(254)

F := FrameData(Omega, N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(255)

DGsetup(F, [X], [omega]):

DGinfo(N, "FrameIndependentVariables");

x,y,z

(256)

 

Example 3.

DGsetup([x, y], [u], E, 2):

DGinfo(E, "FrameIndependentVariables");

x,y

(257)

 

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(258)

DGsetup(L1):

DGinfo(Alg1, "FrameIndependentVariables");

_z14,_z15,_z16,_z17

(259)

"FrameInformation": a complete display of all information pertaining to a given frame.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameInformation");

frame name: M

library name: CoordinateProtocol

Frame Variables:

x,y,z

Frame Labels

D_x,D_y,D_z

Coframe Labels

dx,dy,dz

--------------

(260)

 

Example 2.

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

F := FrameData([y*dx, z*dy, dz], N);

FdΘ1=Θ1Θ2yz,dΘ2=Θ2Θ3z,dΘ3=0

(261)

DGsetup(F, [W], [omega]):

DGinfo(N, "FrameInformation");

frame name: N

library name: AnholonomicFrameProtocol

Frame Variables:

x,y,z

Frame Labels

W1,W2,W3

Coframe Labels

ω1,ω2,ω3

ext_d:,x,ω1y

ext_d:,y,ω2z

ext_d:,z,ω3

ext_d:,ω1,ω1yzω2

ext_d:,ω2,ω2zω3

ext_d:,ω3,0ω1ω2

--------------

(262)

Example 3.

DGsetup([x, y], [u], E, 2):

DGinfo(E, "FrameInformation");

frame name: E

library name: CoordinateProtocol

Frame Variables:

x,y,u,u1,u2,u1,1,u1,2,u2,2

Frame Labels

D_x,D_y,D_u,D_u1,D_u2,D_u1,1,D_u1,2,D_u2,2

Coframe Labels

dx,dy,du,du1,du2,du1,1,du1,2,du2,2

Horizontal Coframe Labels

Dx,Dy

Vertical Coframe Labels

Cu,Cu1,Cu2,Cu1,1,Cu1,2,Cu2,2

--------------

(263)

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(264)

DGsetup(L1):

DGinfo(Alg1, "FrameInformation");

frame name: Alg1

library name: LieAlgebraProtocol

Frame Variables:

_z14,_z15,_z16,_z17

Frame Labels

e1,e2,e3,e4

Coframe Labels

θ1,θ2,θ3,θ4

ext_d:,θ1,θ2θ4

ext_d:,θ2,0θ1θ2

ext_d:,θ3,θ3θ4

ext_d:,θ4,0θ1θ2

--------------

(265)

"FrameJetDimension": the total dimension of the frame.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameJetDimension");

3

(266)

Example 2.

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

DGinfo(N, "FrameJetDimension");

5

(267)

Example 3.

DGsetup([x, y], [u], E, 2):

DGinfo(J, "FrameJetDimension");

11

(268)

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3

(269)

DGsetup(L1):

DGinfo(Alg1, "FrameJetDimension");

4

(270)

"FrameJetForms": the basis of all 1-forms for the frame.

with(DifferentialGeometry): with(Tools):

 

Example 1.

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

DGinfo(M, "FrameJetForms");

dx,dy,dz

(271)

Example 2.

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

DGinfo(N, "FrameJetForms");

dx,dy,dz,du,dv

(272)

Example 3.

DGsetup([x, y], [u], J, 2):

DGinfo(J, "FrameJetForms");

dx,dy,du,du1,du2,du1,1,du1,2,du2,2

(273)

Example 4.

L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);

L1e2,e4=e1,e3,e4=e3