DGinfo - Maple Help

All Products Maple MapleSim

Home : Support : Online Help : Mathematics : DifferentialGeometry : Tools : DGinfo

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);

$α1 ≔ Dx ⋀ Dy$

(1)

>	DGinfo(alpha1, "BiformDegree");

$[2, 0]$

(2)

Example 2.

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

$α2 ≔ Dx ⋀ Cu []$

(3)

>	DGinfo(alpha2, "BiformDegree");

$[1, 1]$

(4)

Example 3.

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

$α3 ≔ {Cu}_{1} ⋀ {Cu}_{2}$

(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(adx &w dy + bdx &w dz + cdy &w dz + ddx &w dw + e*dz &w dw);

$α ≔ a dx ⋀ dy + b dx ⋀ dz + d dx ⋀ dw + c dy ⋀ dz + e dz ⋀ dw$

(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(adx &w dy + bdx &w dz + bdy &w dz + cdx &w dw + a*dz &w dw);

$α ≔ a dx ⋀ dy + b dx ⋀ dz + c dx ⋀ dw + b dy ⋀ dz + a dz ⋀ dw$

(11)

>	DGinfo(alpha, "CoefficientSet");

$\{a, b, c\}$

(12)

Example 2.

>	X := DGzero("vector");

$X ≔ 0 D_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(adx &w dy + bdx &w dz + cdy &w dz + ddx &w dw + e*dz &w dw);

$α ≔ a dx ⋀ dy + b dx ⋀ dz + d dx ⋀ dw + c dy ⋀ dz + e dz ⋀ dw$

(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]]);

$Δ ≔ [\{u_{1}, v_{1}\}, [u_{2} + v_{1}, u_{1} - v_{2}]]$

(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]]);

$Δ ≔ [\{u_{1}, v_{1}\}, [u_{2} + v_{1}, u_{1} - v_{2}]]$

(21)

>	DGinfo(Delta, "DiffeqVariables");

$\{u_{1}, v_{1}\}$

(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(3dx &w dy + 4dy &w dz - dx &w dz);

$β ≔ 3 dx ⋀ dy - dx ⋀ dz + 4 dy ⋀ dz$

(25)

>	DGinfo(beta, "FormDegree");

$2$

(26)

Example 3.

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

$ν ≔ dx ⋀ dy ⋀ dz$

(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 := ux + vy;

$f1 ≔ u x + v y$

(29)

>	DGinfo(f1, "FunctionOrder");

$0$

(30)

Example 2.

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

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

$f1 ≔ u_{1} x + u_{2}$

(31)

>	DGinfo(f1, "FunctionOrder");

$1$

(32)

Example 3.

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

$f1 ≔ u_{1, 1, 2} x + u_{2, 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(aD_x + bD_y + c*D_z);

$X ≔ a D_x + b D_y + c D_z$

(35)

>	DGinfo(X, "ObjectAttributes");

$[vector, M, []]$

(36)

Example 2.

>	alpha := evalDG(ddx &w dy + edx &w dz + f*dy &w dz);

$α ≔ d dx ⋀ dy + e dx ⋀ dz + f dy ⋀ dz$

(37)

>	DGinfo(alpha, "ObjectAttributes");

$[form, M, 2]$

(38)

Example 3.

>	T := evalDG(rD_x &t dx + sD_z&t dy + t*D_z &t dx);

$T ≔ r D_x dx + t D_z dx + s D_z dy$

(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 = xyz]);

$Φ ≔ [u = x^{2} + y^{2} + z^{2}, v = x y z]$

(41)

>	DGinfo(Phi, "ObjectAttributes");

$[transformation, [[M, 0], [N, 0]], [], [[\begin{array}{c} 2 x & 2 y & 2 z \\ y z & x z & x y \end{array}]]]$

(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(aD_x + bD_y + c*D_z);

$X ≔ a D_x + b D_y + c D_z$

(49)

>	DGinfo(X, "ObjectComponents");

$[[[1], a], [[2], b], [[3], c]]$

(50)

Example 2.

>	alpha := evalDG(ddx &w dy + edx &w dz + f*dy &w dz);

$α ≔ d dx ⋀ dy + e dx ⋀ dz + f dy ⋀ dz$

(51)

>	DGinfo(alpha, "ObjectComponents");

$[[[1, 2], d], [[1, 3], e], [[2, 3], f]]$

(52)

Example 3.

>	T := evalDG(rD_x &t dx + sD_z&t dy + t*D_z &t dx);

$T ≔ r D_x dx + t D_z dx + s D_z dy$

(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= xyz]);

$Φ ≔ [u = x^{2} + y^{2} + z^{2}, v = x y z]$

(55)

>	DGinfo(Phi, "ObjectComponents");

$[[x^{2} + y^{2} + z^{2}, u], [x y z, 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);

$X ≔ D_x - 3 D_y$

(57)

>	DGinfo(X, "ObjectFrame");

$M$

(58)

Example 2.

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

$T ≔ D_r D_s dt$

(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(yD_x + zD_z);

$X ≔ y D_x + z D_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(wdx &w dy + xdx &w dw + z^2*dy &w dw);

$α ≔ w dx ⋀ dy + x dx ⋀ dw + z^{2} dy ⋀ dw$

(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;

$f ≔ u_{2} x + v [] y$

(65)

>	DGinfo(f, "ObjectOrder");

$1$

(66)

Example 2.

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

$α ≔ x {du}_{1} + {du}_{2, 2}$

(67)

>	DGinfo(alpha, "ObjectOrder");

$2$

(68)

Example 3.

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

$β ≔ u_{2, 2, 2, 2} dy + x {du}_{1, 1, 2}$

(69)

>	DGinfo(beta, "FunctionOrder");

$4$

(70)

Example 4.

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

$X ≔ u_{1} D_u []$

(71)

>	X3 := Prolong(X, 2);

$X3 ≔ u_{1} D_u [] + u_{1, 1} {D_u}_{1} + u_{1, 2} {D_u}_{2} + u_{1, 1, 1} {D_u}_{1, 1} + u_{1, 1, 2} {D_u}_{1, 2} + u_{1, 2, 2} {D_u}_{2, 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);

$f ≔ \sin (x) \cos (y)$

(74)

>	DGinfo(f, "ObjectType");

$DGscalar$

(75)

Example 2.

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

$X ≔ D_x + y D_u []$

(76)

>	DGinfo(X, "ObjectType");

$vector$

(77)

Example 3.

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

$α ≔ dx ⋀ dy + dx ⋀ {du}_{1}$

(78)

>	DGinfo(alpha, "ObjectType");

$form$

(79)

Example 4.

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

$θ ≔ Dx ⋀ {Cu}_{1}$

(80)

>	DGinfo(theta, "ObjectType");

$biform$

(81)

Example 5.

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

$T ≔ dx D_y + dy D_y$

(82)

>	DGinfo(T, "ObjectType");

$tensor$

(83)

Example 6.

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

$A ≔ [\begin{array}{c} 1 \\ 2 \end{array}]$

(84)

>	DGinfo(A, "ObjectType");

$Vector$

(85)

Example 7.

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

$B ≔ [\begin{array}{c} 1 & 2 \end{array}]$

(86)

>	DGinfo(B, "ObjectType");

$Matrix$

(87)

Example 8.

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

$B ≔ [\begin{array}{c} 1 & 2 \\ 3 & 4 \end{array}]$

(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, xD_x, x^2D_x]));

$L ≔ [[e1, e2] = e1, [e1, e3] = 2 e2, [e2, e3] = e3]$

(92)

>	DGinfo(L, "ObjectType");

$LieAlgebra$

(93)

Example 11.

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

$frame name: M$

(94)

>	F := FrameData([ydx, xdy], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y x}, d Θ2 = \frac{Θ1 ⋀ Θ2}{y x}]$

(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]])];

$R ≔ [[\begin{array}{c} 1 & 0 \\ 0 & 0 \end{array}], [\begin{array}{c} 0 & 1 \\ 0 & 0 \end{array}], [\begin{array}{c} 0 & 0 \\ 0 & 1 \end{array}]]$

(98)

>	L := LieAlgebraData(R, Alg);

$L ≔ [[e1, e2] = e2, [e2, e3] = e2]$

(99)

>	DGsetup(L);

$Lie algebra: Alg$

(100)

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

$ρ ≔ [[e1, [\begin{array}{c} 1 & 0 \\ 0 & 0 \end{array}]], [e2, [\begin{array}{c} 0 & 1 \\ 0 & 0 \end{array}]], [e3, [\begin{array}{c} 0 & 0 \\ 0 & 1 \end{array}]]]$

(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);

$g ≔ dx dx + dy dy$

(103)

Example 1.

>	rho := MetricDensity(g, 3);

$ρ ≔ 1$

(104)

>	T1 := D_x &tensor rho;

$T1 ≔ D_x$

(105)

>	DGinfo(T1, "TensorDensityType");

$[[bas, 3]]$

(106)

Example 2.

>	T2 := PermutationSymbol("cov_vrt");

$T2 ≔ du dv dw - du dw dv - dv du dw + dv dw du + dw du dv - dw dv du$

(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);

$T1 ≔ dx dx dx$

(109)

>	DGinfo(T1, "TensorGenerators");

$\{[cov_bas, 1]\}$

(110)

Example 2.

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

$T2 ≔ dx D_y dy$

(111)

>	DGinfo(T2, "TensorGenerators");

$\{[con_bas, 2], [cov_bas, 1], [cov_bas, 2]\}$

(112)

Example 3.

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

$T3 ≔ du D_v dy$

(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);

$T1 ≔ D_x D_y$

(123)

>	DGinfo(T1, "TensorIndexType");

$[con_bas, con_bas]$

(124)

Example 2.

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

$T2 ≔ dx D_y$

(125)

>	DGinfo(T2, "TensorIndexType");

$[cov_bas, con_bas]$

(126)

Example 3.

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

$T3 ≔ du D_v$

(127)

>	DGinfo(T3, "TensorIndexType");

$[cov_vrt, con_vrt]$

(128)

Example 4.

>	T4 := evalDG(D_x &t D_v);

$T4 ≔ D_x D_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);

$T1 ≔ D_x D_y$

(131)

>	DGinfo(T1, "TensorType");

$[[con_bas, con_bas], []]$

(132)

Example 2.

>	T2 := PermutationSymbol("con_bas");

$T2 ≔ D_x D_y - D_y D_x$

(133)

>	DGinfo(T2, "TensorType");

$[[con_bas, con_bas], [[bas, 1]]]$

(134)

Example 3.

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

$T3 ≔ du D_v$

(135)

>	DGinfo(T3, "TensorType");

$[[cov_vrt, con_vrt], []]$

(136)

Example 4.

>	T4 := PermutationSymbol("cov_vrt");

$T4 ≔ du dv - dv du$

(137)

>	DGinfo(T4, "TensorType");

$[[cov_vrt, cov_vrt], [[vrt, −1]]]$

(138)

Example 5.

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

$T5 ≔ dx dy D_u D_v - dx dy D_v D_u - dy dx D_u D_v + dy dx D_v D_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[]);

$X1 ≔ D_x + u [] D_u []$

(141)

>	X1a := AssignVectorType(X1);

$X1a ≔ D_x + u [] D_u []$

(142)

>	DGinfo(X1a, "VectorType");

$[projectable, 0]$

(143)

Example 2.

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

$X2 ≔ u [] D_x - x D_u [] - (u_{1}^{2} + 1) {D_u}_{1} - u_{2} u_{1} {D_u}_{2}$

(144)

>	DGinfo(X2, "VectorType");

$[point, 1]$

(145)

Example 3.

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

$X3 ≔ - u [] u_{2} D_x - u [] u_{1} D_y - u [] u_{1} u_{2} D_u [] + u_{1}^{2} u_{2} {D_u}_{1} + u_{2}^{2} u_{1} {D_u}_{2}$

(146)

>	X3a := AssignVectorType(X3);

$X3a ≔ - u [] u_{2} D_x - u [] u_{1} D_y - u [] u_{1} u_{2} D_u [] + u_{1}^{2} u_{2} {D_u}_{1} + u_{2}^{2} u_{1} {D_u}_{2}$

(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]);

$LD ≔ [[e3, 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, [\begin{array}{c} 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{array}]], [e2, [\begin{array}{c} 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{array}]], [e3, [\begin{array}{c} 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{array}]], [e4, [\begin{array}{c} 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{array}]], [e5, [\begin{array}{c} 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & −1 & 0 & 0 \\ 0 & 0 & 0 & −1 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{array}]]]$

(150)

>	DGsetup(Alg, rho, AlgV);

$Lie algebra with coefficients: AlgV$

(151)

Example 1.

>	alpha1 := evalDG(w3 *theta5);

$α1 ≔ w3 θ5$

(152)

>	DGinfo(alpha1, "Weight");

$−1$

(153)

Example 2.

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

$α2 ≔ w3 θ1 ⋀ θ5$

(154)

>	DGinfo(alpha2, "Weight");

$2$

(155)

Example 3.

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

$α3 ≔ w1 θ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 = x y, v = \frac{1}{x} + \frac{1}{y}]$

(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]);

$Φ1 ≔ [u = x y, v = \frac{1}{x} + \frac{1}{y}]$

(160)

>	DGinfo(Phi1, "DomainOrder");

$0$

(161)

Example 2.

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

$Φ2 ≔ [x = w_{1}, y = w_{1, 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 = x y, v = \frac{1}{x} + \frac{1}{y}, w = x + y]$

(164)

>	DGinfo(Phi, "JacobianMatrix");

$[\begin{array}{c} y & x \\ - \frac{1}{x^{2}} & - \frac{1}{y^{2}} \\ 1 & 1 \end{array}]$

(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 = x y, v = \frac{1}{x} + \frac{1}{y}]$

(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]);

$Φ1 ≔ [u = x y, v = \frac{1}{x} + \frac{1}{y}]$

(168)

>	DGinfo(Phi1, "RangeOrder");

$0$

(169)

Example 2.

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

$Φ2 ≔ [t = x, w [] = y, w_{1} = y^{2}]$

(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]])];

$R ≔ [[\begin{array}{c} 1 & 0 \\ 0 & 0 \end{array}], [\begin{array}{c} 0 & 1 \\ 0 & 0 \end{array}], [\begin{array}{c} 0 & 0 \\ 0 & 1 \end{array}]]$

(173)

>	L := LieAlgebraData(R, Alg);

$L ≔ [[e1, e2] = e2, [e2, e3] = e2]$

(174)

>	DGsetup(L);

$Lie algebra: Alg$

(175)

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

$ρ ≔ [[e1, [\begin{array}{c} 1 & 0 \\ 0 & 0 \end{array}]], [e2, [\begin{array}{c} 0 & 1 \\ 0 & 0 \end{array}]], [e3, [\begin{array}{c} 0 & 0 \\ 0 & 1 \end{array}]]]$

(176)

>	DGinfo(rho, "RepresentationMatrices");

$[[\begin{array}{c} 1 & 0 \\ 0 & 0 \end{array}], [\begin{array}{c} 0 & 1 \\ 0 & 0 \end{array}], [\begin{array}{c} 0 & 0 \\ 0 & 1 \end{array}]]$

(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]);

$Φ1 ≔ [x = x^{2}, u [] = u [] x]$

(178)

>	Phi1A := AssignTransformationType(Phi1);

$Phi1A ≔ [x = x^{2}, u [] = u [] x]$

(179)

>	DGinfo(Phi1A, "TransformationType");

$[projectable, 0]$

(180)

Example 2.

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

$Φ2 ≔ [x = u [], u [] = x]$

(181)

>	Phi2A := AssignTransformationType(Phi2);

$Phi2A ≔ [x = 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]]);

$Φ3 ≔ [x = - 2 u_{1} + x, u [] = - u_{1}^{2} + u [], u_{1} = u_{1}]$

(184)

>	Phi3A := AssignTransformationType(Phi3);

$Phi3A ≔ [x = - 2 u_{1} + x, u [] = - u_{1}^{2} + u [], u_{1} = u_{1}]$

(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]);

$LD ≔ [[e3, 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));

(194)

>	DGsetup(Alg, rho, AlgV):

>	DGinfo(AlgV, "CoefficientGrading");

$table ([w2 = −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([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, 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]]]);

$L1 ≔ [[e2, 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([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(208)

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

>	DGinfo(N, "ExteriorDerivativeFormStructureEquations");

$[- \frac{ω1}{y z} ⋀ ω2, - \frac{ω2}{z} ⋀ ω3, 0 ω1 ⋀ ω2]$

(209)

Example 3.

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

$L1 ≔ [[e2, 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([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(213)

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

>	DGinfo(N, "ExteriorDerivativeFunctionStructureEquations");

$[\frac{ω1}{y}, \frac{ω2}{z}, ω3]$

(214)

Example 3.

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

$L1 ≔ [[e2, 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]]]);

$L1 ≔ [[e2, 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([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, 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]]]);

$L1 ≔ [[e2, 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([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, 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]]]);

$L1 ≔ [[e2, 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([ydx, zdy, dz],N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, 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 [], u_{1}, u_{2}, u_{1, 1}, u_{1, 2}, u_{2, 2}, Cu [], {Cu}_{1}, {Cu}_{2}, {Cu}_{1, 1}, {Cu}_{1, 2}, {Cu}_{2, 2}, Dx, Dy, dx, dy, du [], {du}_{1}, {du}_{2}, {du}_{1, 1}, {du}_{1, 2}, {du}_{2, 2}, D_x, D_y, D_u [], {D_u}_{1}, {D_u}_{2}, {D_u}_{1, 1}, {D_u}_{1, 2}, {D_u}_{2, 2}\}$

(248)

Example 4.

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

$L1 ≔ [[e2, 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([ydx, zdy, dz]);

$Ω ≔ [y dx, z dy, dz]$

(254)

>	F := FrameData(Omega, N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, 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]]]);

$L1 ≔ [[e2, 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([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, 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, \frac{ω1}{y}$

$ext_d:, y, \frac{ω2}{z}$

$ext_d:, z, ω3$

$ext_d:, ω1, - \frac{ω1}{y z} ⋀ ω2$

$ext_d:, ω2, - \frac{ω2}{z} ⋀ ω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 [], u_{1}, u_{2}, u_{1, 1}, u_{1, 2}, u_{2, 2}]$

$Frame Labels$

$[D_x, D_y, D_u [], {D_u}_{1}, {D_u}_{2}, {D_u}_{1, 1}, {D_u}_{1, 2}, {D_u}_{2, 2}]$

$Coframe Labels$

$[dx, dy, du [], {du}_{1}, {du}_{2}, {du}_{1, 1}, {du}_{1, 2}, {du}_{2, 2}]$

$Horizontal Coframe Labels$

$[Dx, Dy]$

$Vertical Coframe Labels$

$[Cu [], {Cu}_{1}, {Cu}_{2}, {Cu}_{1, 1}, {Cu}_{1, 2}, {Cu}_{2, 2}]$

$--------------$

(263)

Example 4.

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

$L1 ≔ [[e2, 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]]]);

$L1 ≔ [[e2, 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 [], {du}_{1}, {du}_{2}, {du}_{1, 1}, {du}_{1, 2}, {du}_{2, 2}]$

(273)

Example 4.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(274)

>	DGsetup(L1):

>	DGinfo(Alg1, "FrameJetForms");

$[θ1, θ2, θ3, θ4]$

(275)

"FrameJetOrder": the jet space order of the frame.

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

Example 1.

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

>	DGinfo(N, "FrameJetOrder");

$0$

(276)

Example 2.

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

>	DGinfo(J, "FrameJetOrder");

$2$

(277)

Example 3.

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

>	Prolong(4);

$2$

(278)

>	DGinfo(J, "FrameJetOrder");

$4$

(279)

"FrameJetVariables": the list of all variables for the frame.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "FrameJetVariables");

$[x, y, z]$

(280)

Example 2.

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

>	DGinfo(N, "FrameJetVariables");

$[x, y, z, u, v]$

(281)

Example 3.

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

>	DGinfo(J, "FrameJetVariables");

$[x, y, u [], u_{1}, u_{2}, u_{1, 1}, u_{1, 2}, u_{2, 2}]$

(282)

Example 4.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(283)

>	DGsetup(L1):

>	DGinfo(Alg1, "FrameJetVariables");

$[_z14,_z15,_z16,_z17]$

(284)

"FrameJetVectors": the list of all basis vectors for the frame.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "FrameJetVectors");

$[D_x, D_y, D_z]$

(285)

Example 2.

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

>	DGinfo(N, "FrameJetVectors");

$[D_x, D_y, D_z, D_u, D_v]$

(286)

Example 3.

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

>	DGinfo(J, "FrameJetVectors");

$[D_x, D_y, D_u [], {D_u}_{1}, {D_u}_{2}, {D_u}_{1, 1}, {D_u}_{1, 2}, {D_u}_{2, 2}]$

(287)

Example 4.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(288)

>	DGsetup(L1):

>	DGinfo(Alg1, "FrameJetVectors");

$[e1, e2, e3, e4]$

(289)

"FrameLabels": list the labels used to input and display the basis of vectors for the tangent space.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "FrameLabels");

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

(290)

Example 2.

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

>	F := FrameData([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(291)

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

>	DGinfo(N, "FrameLabels");

$[[W1, []], [W2, []], [W3, []]]$

(292)

Example 3.

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

>	DGinfo(E, "FrameLabels");

$[[D_x, []], [D_y, []], [D_u, [[]]], [D_u, [[1]]], [D_u, [[2]]], [D_u, [[1, 1]]], [D_u, [[1, 2]]], [D_u, [[2, 2]]]]$

(293)

Example 4.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(294)

>	DGsetup(L1):

>	DGinfo(Alg1, "FrameLabels");

$[[e1, []], [e2, []], [e3, []], [e4, []]]$

(295)

"FrameNames": the list of initialized frames

>	with(DifferentialGeometry): with(Tools):

>	DGinfo("FrameNames");

$[Alg, Alg1, AlgV, E, J, M, N, P, V,_TempDGFrame1,_TempDGFrame2]$

(296)

"FrameProtocol": the name of the frame protocol; this protocol controls the computation rules for many operations in DifferentialGeometry.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "FrameProtocol");

$CoordinateProtocol$

(297)

Example 2.

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

>	F := FrameData([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(298)

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

>	DGinfo(N, "FrameProtocol");

$AnholonomicFrameProtocol$

(299)

Example 3.

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

>	DGinfo(E, "FrameProtocol");

$CoordinateProtocol$

(300)

Example 4.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(301)

>	DGsetup(L1):

>	DGinfo(Alg1, "FrameProtocol");

$LieAlgebraProtocol$

(302)

"FrameVerticalBiforms": the list of the contact 1-forms for a frame defining a jet space.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "FrameVerticalBiforms");

$[]$

(303)

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

>	DGinfo(J, "FrameVerticalBiforms");

$[Cu [], Cv [], {Cu}_{1}, {Cu}_{2}, {Cv}_{1}, {Cv}_{2}, {Cu}_{1, 1}, {Cu}_{1, 2}, {Cu}_{2, 2}, {Cv}_{1, 1}, {Cv}_{1, 2}, {Cv}_{2, 2}]$

(304)

"Grading": the grading of a Lie algebra

>	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]);

$LD ≔ [[e3, e5] = e2, [e4, e5] = e3]$

(305)

>	DGsetup(LD);

$Lie algebra: Alg$

(306)

>	DGinfo(Alg, "Grading");

$[−3, −3, −2, −1, −1]$

(307)

"HorizontalCoframeLabels": the list of labels, used for display purposes, for the horizontal biforms defined on a jet space.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "HorizontalCoframeLabels");

$[]$

(308)

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

>	DGinfo(J, "HorizontalCoframeLabels");

$[[Dx, []], [Dy, []]]$

(309)

"LieBracketStructureEquations": a matrix giving the Lie brackets of the frame basis vectors for a frame with protocol "LieAlgebra" or "AnholonomicFrame".

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "LieBracketStructureEquations");

$[[\begin{array}{c} 0 \end{array}]]$

(310)

Example 2.

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

>	F := FrameData([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(311)

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

>	DGinfo(N, "LieBracketStructureEquations");

$[[\begin{array}{c} 0 W1 & \frac{W1}{y z} & 0 W1 \\ - \frac{W1}{y z} & 0 W1 & \frac{W2}{z} \\ 0 W1 & - \frac{W2}{z} & 0 W1 \end{array}]]$

(312)

Example 3.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(313)

>	DGsetup(L1):

>	DGinfo(Alg1, "LieBracketStructureEquations");

$[[\begin{array}{c} 0 e1 & 0 e1 & 0 e1 & 0 e1 \\ 0 e1 & 0 e1 & 0 e1 & e1 \\ 0 e1 & 0 e1 & 0 e1 & e3 \\ 0 e1 & - e1 & - e3 & 0 e1 \end{array}]]$

(314)

"LieBracketStructureFunction": a specific structure function for a frame with "LieAlgebra" or "AnholonomicFrame" protocol.

>	with(DifferentialGeometry): with(Tools):

Example 1.

>	DGsetup([x, y, z], M): F := FrameData([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(315)

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

>	DGinfo(N, "LieBracketStructureEquations");

$[[\begin{array}{c} 0 W1 & \frac{W1}{y z} & 0 W1 \\ - \frac{W1}{y z} & 0 W1 & \frac{W2}{z} \\ 0 W1 & - \frac{W2}{z} & 0 W1 \end{array}]]$

(316)

>	DGinfo([1,2,1], "LieBracketStructureFunction");

$\frac{1}{y z}$

(317)

>	DGinfo([2,3,2], "LieBracketStructureFunction");

$\frac{1}{z}$

(318)

>	DGinfo([2,3,3], "LieBracketStructureFunction");

$0$

(319)

Example 2.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(320)

>	DGsetup(L1):

>	DGinfo(Alg1, "LieBracketStructureEquations");

$[[\begin{array}{c} 0 e1 & 0 e1 & 0 e1 & 0 e1 \\ 0 e1 & 0 e1 & 0 e1 & e1 \\ 0 e1 & 0 e1 & 0 e1 & e3 \\ 0 e1 & - e1 & - e3 & 0 e1 \end{array}]]$

(321)

"LieBracketStructureFunctionList ": a list of structure function for a frame with "LieAlgebra" or "AnholonomicFrame" protocol.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "LieBracketStructureFunctionList");

$[[[1, 2, 1], 0]]$

(322)

Example 2.

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

>	F := FrameData([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(323)

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

>	[LieBracket(W1, W2), LieBracket(W1, W3), LieBracket(W2, W3)];

$[\frac{W1}{y z}, 0 W1, \frac{W2}{z}]$

(324)

>	DGinfo(N, "LieBracketStructureFunctionList");

$[[[1, 2, 1], \frac{1}{y z}], [[2, 3, 2], \frac{1}{z}]]$

(325)

Example 3.

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(326)

>	DGsetup(L1):

>	DGinfo(Alg1, "LieBracketStructureFunctionList");

$[[[2, 4, 1], 1], [[3, 4, 3], 1]]$

(327)

"LieDerivativeFunctionStructureEquations": a matrix specifying the Lie derivatives of the coordinate variables with respect to the frame basis vectors for a frame with "AnholonomicFrame" protocol.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	F := FrameData([ydx, zdy, dz], N);

$F ≔ [d Θ1 = - \frac{Θ1 ⋀ Θ2}{y z}, d Θ2 = - \frac{Θ2 ⋀ Θ3}{z}, d Θ3 = 0]$

(328)

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

>	DGinfo(N, "LieDerivativeFunctionStructureEquations");

$[[\begin{array}{c} \frac{1}{y} & 0 & 0 \\ 0 & \frac{1}{z} & 0 \\ 0 & 0 & 1 \end{array}]]$

(329)

"VerticalCoframeLabels": the list of labels, used for display proposes, for the vertical biforms defined on jet space.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	DGinfo(M, "VerticalCoframeLabels");

$[]$

(330)

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

>	DGinfo(J, "VerticalCoframeLabels");

$[[Cu, [[]]], [Cv, [[]]], [Cu, [[1]]], [Cu, [[2]]], [Cv, [[1]]], [Cv, [[2]]]]$

(331)

Miscellaneous

"JetNotation": the choice of jet notation for a frame defining the jet space or fiber bundle.

>	with(DifferentialGeometry): with(Tools):

>	DGsetup([x, y], [u], J1, 2):

>	DGinfo(J1, "FrameJetVariables");

$[x, y, u [], u_{1}, u_{2}, u_{1, 1}, u_{1, 2}, u_{2, 2}]$

(332)

>	DGinfo(J1, "JetNotation");

$JetNotation1$

(333)

>	Preferences("JetNotation", "JetNotation2");

$JetNotation1$

(334)

>	DGsetup([x, y], [u], J2, 2):

>	DGinfo(J2, "FrameJetVariables");

$[x, y, u_{0, 0}, u_{1, 0}, u_{0, 1}, u_{2, 0}, u_{1, 1}, u_{0, 2}]$

(335)

>	DGinfo(J2, "JetNotation");

$JetNotation2$

(336)

"JetIndets": the list of frame variables appearing in a Maple expression. See the Maple indets command.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	f1 := ax^2 + by;

$f1 ≔ a x^{2} + b y$

(337)

>	indets(f1);

$\{a, b, x, y\}$

(338)

>	DGinfo(f1, "JetIndets");

$\{x, y\}$

(339)

Example 2.

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

>	f2 := u[2,2]c + exp(v[])d;

$f2 ≔ u_{2, 2} c + {&ExponentialE;}^{v []} d$

(340)

>	DGinfo(f2, "JetIndets");

$\{u_{2, 2}, v []\}$

(341)

"JetSpaceDimension": the dimension of a jet space of a given order for a given fiber bundle E.

>	with(DifferentialGeometry): with(Tools):

Example 1.

>	DGsetup([x], [u], J1, 1):

>	DGinfo(3, "JetSpaceDimension", J1);

$5$

(342)

>	DGinfo(4, "JetSpaceDimension", J1);

$6$

(343)

Example 2.

>	DGsetup([x, y], [u], J2, 1):

>	DGinfo(2, "JetSpaceDimension", J2);

$8$

(344)

>	DGinfo(3, "JetSpaceDimension", J2);

$12$

(345)

"Keywords": the keyword strings accepted by the DGinfo command.

>	with(DifferentialGeometry): with(Tools):

>	DGinfo("Keywords");

$[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, Properties, RangeFrame, RangeOrder, RepresentationMatrices, TensorDensityType, TensorGenerators, TensorIndexPart1, TensorIndexPart2, TensorIndexType, TensorType, TransformationType, VectorType, VerticalCoframeLabels, Weight]$

(346)

"LieAlgebraDimension": the dimension of a Lie algebra, defined by a LieAlgebraData structure.

>	with(DifferentialGeometry): with(Tools):

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

$L1 ≔ [[e2, e4] = e1, [e3, e4] = e3]$

(347)

>	DGinfo(L1, "LieAlgebraDimension");

$4$

(348)

"NonJetIndets": the list of Maple names other than frame variables appearing in a Maple expression.

>	with(DifferentialGeometry): with(Tools):

Example 1.

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

>	f1 := ax^2 + by;

$f1 ≔ a x^{2} + b y$

(349)

>	indets(f1);

$\{a, b, x, y\}$

(350)

>	DGinfo(f1, "NonJetIndets");

$\{a, b\}$

(351)

Example 2.

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

>	f2 := u[2,2]c + exp(v[])d;

$f2 ≔ u_{2, 2} c + {&ExponentialE;}^{v []} d$

(352)

>	DGinfo(f2, "NonJetIndets");

$\{c, d\}$

(353)

Maple

Maple Add-Ons

MapleSim

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim

Maple

Powerful math software that is easy to use

Maple Add-Ons

MapleSim

Advanced System Level Modeling

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim