DifferentialGeometry[Tools]
DGinfo
obtain information about DifferentialGeometry objects
Calling Sequence
Parameters
Description
Function, Vector, DifferentialForm, and Tensor Information
Transformation Information
Frame Information
Miscellaneous
DGinfo(X, keyword)
X
-
a DifferentialGeometry object
keyword
a keyword string
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(...).
"BiformDegree"
with(DifferentialGeometry): with(Tools):
DGsetup([x, y], [u], E, 2):
Example 1.
alpha1 := evalDG(Dx &wedge Dy);
α1≔Dx⁢⋀⁢Dy
DGinfo(alpha1, "BiformDegree");
2,0
Example 2.
alpha2 := evalDG(Dx &wedge Cu[]);
α2≔Dx⁢⋀⁢Cu
DGinfo(alpha2, "BiformDegree");
1,1
Example 3.
alpha3 := evalDG(Cu[1] &wedge Cu[2]);
α3≔Cu1⁢⋀⁢Cu2
DGinfo(alpha3, "BiformDegree");
0,2
"CoefficientList": list some or all of the coefficients of a vector, differential form, or tensor.
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);
α≔a⁢dx⁢⋀⁢dy+b⁢dx⁢⋀⁢dz+d⁢dx⁢⋀⁢dw+c⁢dy⁢⋀⁢dz+e⁢dz⁢⋀⁢dw
DGinfo(alpha, "CoefficientList", "all");
a,b,d,c,e
DGinfo(alpha, "CoefficientList", [dx &w dy, dx &w dz, dy &w dw]);
a,b,0
DGinfo(alpha, "CoefficientList", [[1,2], [1,3], [2,4]]);
"CoefficientSet": find the set of all the coefficients of a vector, differential form, or tensor.
alpha := evalDG(a*dx &w dy + b*dx &w dz + b*dy &w dz + c*dx &w dw + a*dz &w dw);
α≔a⁢dx⁢⋀⁢dy+b⁢dx⁢⋀⁢dz+c⁢dx⁢⋀⁢dw+b⁢dy⁢⋀⁢dz+a⁢dz⁢⋀⁢dw
DGinfo(alpha, "CoefficientSet");
a,b,c
X := DGzero("vector");
X≔0⁢D_x
DGinfo(X, "CoefficientSet");
0
"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,u1−v2
DGinfo(Delta, "DiffeqType");
evolutionary,0
"DiffeqVariables": list the jet variables in the differential equation to be solved for
DGinfo(Delta, "DiffeqVariables");
u1,v1
"FormDegree": the degree of a differential form
DGsetup([x, y, z], M):
alpha := evalDG(dx +dy);
α≔dx+dy
DGinfo(alpha, "FormDegree");
1
beta := evalDG(3*dx &w dy + 4*dy &w dz - dx &w dz);
β≔3⁢dx⁢⋀⁢dy−dx⁢⋀⁢dz+4⁢dy⁢⋀⁢dz
DGinfo(beta, "FormDegree");
2
nu := evalDG(dx &w dy &w dz);
ν≔dx⁢⋀⁢dy⁢⋀⁢dz
DGinfo(nu, "FormDegree");
3
"FunctionOrder": the order of the highest jet coordinate appearing in a Maple expression.
DGsetup([x, y], [u, v], E):
f1 := u*x + v*y;
f1≔u⁢x+v⁢y
DGinfo(f1, "FunctionOrder");
DGsetup([x, y], [u], J, 1):
f1 := u[1]*x + u[2];
f1≔u1⁢x+u2
f1 := u[1, 1, 2]*x + u[2, 2, 2, 2];
f1≔u1,1,2⁢x+u2,2,2,2
4
"ObjectAttributes": list all the properties of a vector, differential form, tensor, or transformation.
DGsetup([x, y, z], M): DGsetup([u, v], N):
X := evalDG(a*D_x + b*D_y + c*D_z);
X≔a⁢D_x+b⁢D_y+c⁢D_z
DGinfo(X, "ObjectAttributes");
vector,M,
alpha := evalDG(d*dx &w dy + e*dx &w dz + f*dy &w dz);
α≔d⁢dx⁢⋀⁢dy+e⁢dx⁢⋀⁢dz+f⁢dy⁢⋀⁢dz
DGinfo(alpha, "ObjectAttributes");
form,M,2
T := evalDG(r*D_x &t dx + s*D_z&t dy + t*D_z &t dx);
T≔r⁢D_x⁢dx+t⁢D_z⁢dx+s⁢D_z⁢dy
DGinfo(T, "ObjectAttributes");
tensor,M,con_bas,cov_bas,
Example 4.
Phi := Transformation(M, N, [u = x^2 + y^2 + z^2, v = x*y*z]);
Φ≔u=x2+y2+z2,v=x⁢y⁢z
DGinfo(Phi, "ObjectAttributes");
transformation,M,0,N,0,,2⁢x2⁢y2⁢zy⁢zx⁢zx⁢y
Example 5.
DGsetup([[gamma1, gamma2, gamma3, gamma4], chi = dgform(3)], [], P):
ExteriorDerivative(chi);
d⁢χ
DGinfo(dchi, "ObjectAttributes");
form,P,4,d,5
Example 6.
Hook(D_gamma1, chi);
ι1⁢χ
DGinfo(i_1chi, "ObjectAttributes");
form,P,2,hook,1,5
Example 7.
Hook([D_gamma2, D_gamma3], chi);
ι2,3⁢χ
DGinfo(i_2_3chi, "ObjectAttributes");
form,P,1,hook,2,3,5
"ObjectComponents": list all the components of a vector, differential form, tensor, or transformation.
DGinfo(X, "ObjectComponents");
1,a,2,b,3,c
DGinfo(alpha, "ObjectComponents");
1,2,d,1,3,e,2,3,f
DGinfo(T, "ObjectComponents");
1,1,r,3,1,t,3,2,s
Phi := Transformation(M, N, [u = x^2 + y^2 + z^2, v= x*y*z]);
DGinfo(Phi, "ObjectComponents");
x2+y2+z2,u,x⁢y⁢z,v
"ObjectFrame": return the frame with respect to which the object is defined.
DGsetup([x, y], [u], M, 1): DGsetup([r,s,t], N):
X := evalDG(D_x -3*D_y);
X≔D_x−3⁢D_y
DGinfo(X, "ObjectFrame");
M
T := evalDG(D_r &t D_s &t dt);
T≔D_r⁢D_s⁢dt
DGinfo(T, "ObjectFrame");
N
"ObjectGenerators": list the monomial vectors in a vector or the monomial 1-forms in a differential form.
X := evalDG(y*D_x + z*D_z);
X≔y⁢D_x+z⁢D_z
DGinfo(X, "ObjectGenerators");
1,3
This means that X has only the 1st and 3rd elements from the standard basis for the tangent bundle.
alpha := evalDG(w*dx &w dy + x*dx &w dw + z^2*dy &w dw);
α≔w⁢dx⁢⋀⁢dy+x⁢dx⁢⋀⁢dw+z2⁢dy⁢⋀⁢dw
DGinfo(alpha, "ObjectGenerators");
1,2,4
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.
DGsetup([x, y], [u, v], E, 3):
f := u[2]*x + v[]*y;
f≔u2⁢x+v⁢y
DGinfo(f, "ObjectOrder");
alpha := evalDG(du[1]*x + du[2,2]);
α≔x⁢du1+du2,2
DGinfo(alpha, "ObjectOrder");
beta := evalDG(du[1, 1, 2]*x + u[2, 2, 2, 2]*dy);
β≔u2,2,2,2⁢dy+x⁢du1,1,2
DGinfo(beta, "FunctionOrder");
X := evalDG(u[1]*D_u[]);
X≔u1⁢D_u
X3 := Prolong(X, 2);
X3≔u1⁢D_u+u1,1⁢D_u1+u1,2⁢D_u2+u1,1,1⁢D_u1,1+u1,1,2⁢D_u1,2+u1,2,2⁢D_u2,2
DGinfo(X3, "FunctionOrder");
"ObjectType": the type of the DifferentialGeometry object.
with(DifferentialGeometry): with(Tools): with(LieAlgebras):
DGsetup([x, y], [u], M, 1):
f := sin(x)*cos(y);
f≔sin⁡x⁢cos⁡y
DGinfo(f, "ObjectType");
DGscalar
X := evalDG(D_x + y*D_u[]);
X≔D_x+y⁢D_u
DGinfo(X, "ObjectType");
vector
alpha := evalDG(dx &w dy + dx &w du[1]);
α≔dx⁢⋀⁢dy+dx⁢⋀⁢du1
DGinfo(alpha, "ObjectType");
form
theta := evalDG(Dx &w Cu[1]);
θ≔Dx⁢⋀⁢Cu1
DGinfo(theta, "ObjectType");
biform
T := evalDG(dx &t D_y + dy &t D_y);
T≔dx⁢D_y+dy⁢D_y
DGinfo(T, "ObjectType");
tensor
A := Vector([1, 2]);
A≔12
DGinfo(A, "ObjectType");
Vector
B := Matrix([1, 2]);
B≔12
DGinfo(B, "ObjectType");
Matrix
Example 8.
B:= Matrix([[1, 2], [3, 4]]);
B≔1234
Example 9.
Phi := IdentityTransformation();
Φ≔x=x,y=y,u=u
DGinfo(Phi, "ObjectType");
transformation
Example 10.
L := LieAlgebraData(evalDG([D_x, x*D_x, x^2*D_x]));
L≔e1,e2=e1,e1,e3=2⁢e2,e2,e3=e3
DGinfo(L, "ObjectType");
LieAlgebra
Example 11.
DGsetup([x, y], M);
frame name: M
F := FrameData([y*dx, x*dy], N);
F≔d⁢Θ1=−Θ1⁢⋀⁢Θ2y⁢x,d⁢Θ2=Θ1⁢⋀⁢Θ2y⁢x
DGinfo(F, "ObjectType");
moving_frame
Example 12.
DGsetup([x, y], V);
frame name: V
R := [Matrix([[1, 0], [0, 0]]), Matrix([[0, 1], [0, 0]]), Matrix([[0, 0], [0, 1]])];
R≔1000,0100,0001
L := LieAlgebraData(R, Alg);
L≔e1,e2=e2,e2,e3=e2
DGsetup(L);
Lie algebra: Alg
rho := Representation(Alg, V, R);
ρ≔e1,1000,e2,0100,e3,0001
DGinfo(rho, "ObjectType");
Representation
"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
rho := MetricDensity(g, 3);
ρ≔1
T1 := D_x &tensor rho;
T1≔D_x
DGinfo(T1, "TensorDensityType");
bas,3
T2 := PermutationSymbol("cov_vrt");
T2≔du⁢dv⁢dw−du⁢dw⁢dv−dv⁢du⁢dw+dv⁢dw⁢du+dw⁢du⁢dv−dw⁢dv⁢du
DGinfo(T2, "TensorDensityType");
vrt,−1
"TensorGenerators": a list of the monomial tensors which generate a given tensor.
DGsetup([x, y], [u, v, w], E):
T1 := evalDG(dx &t dx &t dx);
T1≔dx⁢dx⁢dx
DGinfo(T1, "TensorGenerators");
cov_bas,1
T2 := evalDG(dx &t D_y &t dy);
T2≔dx⁢D_y⁢dy
DGinfo(T2, "TensorGenerators");
con_bas,2,cov_bas,1,cov_bas,2
T3 := evalDG(du &t D_v &t dy);
T3≔du⁢D_v⁢dy
DGinfo(T3, "TensorGenerators");
con_vrt,4,cov_bas,2,cov_vrt,3
"TensorIndexPart1": the tensor character of a tensor index type.
DGinfo("con_bas", "TensorIndexPart1");
con
DGinfo("cov_bas", "TensorIndexPart1");
cov
DGinfo("con_vrt", "TensorIndexPart1");
DGinfo("cov_vrt", "TensorIndexPart1");
"TensorIndexPart2": the spatial type of a tensor index type.
DGinfo("con_bas", "TensorIndexPart2");
bas
DGinfo("cov_bas", "TensorIndexPart2");
DGinfo("con_vrt", "TensorIndexPart2");
vrt
DGinfo("cov_vrt", "TensorIndexPart2");
"TensorIndexType": the full tensor index type of a tensor.
T1 := evalDG(D_x &t D_y);
T1≔D_x⁢D_y
DGinfo(T1, "TensorIndexType");
con_bas,con_bas
T2 := evalDG(dx &t D_y);
T2≔dx⁢D_y
DGinfo(T2, "TensorIndexType");
cov_bas,con_bas
T3 := evalDG(du &t D_v);
T3≔du⁢D_v
DGinfo(T3, "TensorIndexType");
cov_vrt,con_vrt
T4 := evalDG(D_x &t D_v);
T4≔D_x⁢D_v
DGinfo(T4, "TensorIndexType");
con_bas,con_vrt
"TensorType": the full tensor index type and weight of a tensor.
DGinfo(T1, "TensorType");
con_bas,con_bas,
T2 := PermutationSymbol("con_bas");
T2≔D_x⁢D_y−D_y⁢D_x
DGinfo(T2, "TensorType");
con_bas,con_bas,bas,1
DGinfo(T3, "TensorType");
cov_vrt,con_vrt,
T4 := PermutationSymbol("cov_vrt");
T4≔du⁢dv−dv⁢du
DGinfo(T4, "TensorType");
cov_vrt,cov_vrt,vrt,−1
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
DGinfo(T5, "TensorType");
cov_bas,cov_bas,con_vrt,con_vrt,bas,−1,vrt,1
"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):
X1 := evalDG(D_x + u[] *D_u[]);
X1≔D_x+u⁢D_u
X1a := AssignVectorType(X1);
X1a≔D_x+u⁢D_u
DGinfo(X1a, "VectorType");
projectable,0
X2 := Prolong(u[]*D_x - x *D_u[], 1);
X2≔u⁢D_x−x⁢D_u−u12+1⁢D_u1−u2⁢u1⁢D_u2
DGinfo(X2, "VectorType");
point,1
X3 := GeneratingFunctionToContactVector(u[]*u[1]*u[2]);
X3≔−u⁢u2⁢D_x−u⁢u1⁢D_y−u⁢u1⁢u2⁢D_u+u12⁢u2⁢D_u1+u22⁢u1⁢D_u2
X3a := AssignVectorType(X3);
X3a≔−u⁢u2⁢D_x−u⁢u1⁢D_y−u⁢u1⁢u2⁢D_u+u12⁢u2⁢D_u1+u22⁢u1⁢D_u2
DGinfo(X3a, "VectorType");
contact,1
Weight": the weight of a monomial form in a graded Lie algebra with coefficients
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
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
DGsetup(Alg, rho, AlgV);
Lie algebra with coefficients: AlgV
alpha1 := evalDG(w3 *theta5);
α1≔w3⁢θ5
DGinfo(alpha1, "Weight");
−1
alpha2 := evalDG(w3 * theta1 &w theta5);
α2≔w3⁢θ1⁢⋀⁢θ5
DGinfo(alpha2, "Weight");
alpha3 := evalDG(w1 * theta3 &w &w theta4 &w theta5);
α3≔w1⁢θ3⁢⋀⁢θ4⁢⋀⁢θ5
DGinfo(alpha3, "Weight");
"DomainFrame": the domain frame of a transformation.
DGsetup([x, y], M): DGsetup([u, v], N):
Phi := Transformation(M, N, [ u =x*y, v= 1/x + 1/y]);
Φ≔u=x⁢y,v=1x+1y
DGinfo(Phi, "DomainFrame");
"DomainOrder": the jet space order of the domain of a transformation.
DGsetup([x, y], M): DGsetup([u, v], N): DGsetup([t], [w], J, 1):
Phi1 := Transformation(M, N, [u =x*y, v= 1/x + 1/y]);
Φ1≔u=x⁢y,v=1x+1y
DGinfo(Phi1, "DomainOrder");
Phi2 := Transformation(J, M, [x = w[1], y = w[1, 1]]);
Φ2≔x=w1,y=w1,1
DGinfo(Phi2, "DomainOrder");
"JacobianMatrix": the Jacobian Matrix of a transformation.
DGsetup([x, y], M): DGsetup([u, v, w], N):
Phi := Transformation(M, N, [u = x*y, v = 1/x + 1/y, w = x + y]);
Φ≔u=x⁢y,v=1x+1y,w=x+y
DGinfo(Phi, "JacobianMatrix");
yx−1x2−1y211
"RangeFrame": the range frame of a transformation.
Phi := Transformation(M, N, [u =x*y, v= 1/x + 1/y]);
DGinfo(Phi, "RangeFrame");
"RangeOrder": the jet space order of the range of a transformation.
DGinfo(Phi1, "RangeOrder");
Phi2 := Transformation(M, J, [t= x, w[]= y, w[1] = y^2]);
Φ2≔t=x,w=y,w1=y2
DGinfo(Phi2, "RangeOrder");
"RepresentationMatrices": the list of matrices defining a representation of a Lie Algebra
with(DifferentialGeometry): with(LieAlgebras): with(Tools):
DGinfo(rho, "RepresentationMatrices");
1000,0100,0001
"TransformationType": the type (projectionable, point, contact, ...) of a transformation. See AssignTransformationType for details.
DGsetup([x], [u], E, 1):
Phi1 := Transformation(E, E, [x = x^2, u[] = u[]*x]);
Φ1≔x=x2,u=u⁢x
Phi1A := AssignTransformationType(Phi1);
Phi1A≔x=x2,u=u⁢x
DGinfo(Phi1A, "TransformationType");
Phi2 := Transformation(E, E, [x = u[], u[] = x]);
Φ2≔x=u,u=x
Phi2A := AssignTransformationType(Phi2);
Phi2A≔x=u,u=x
DGinfo(Phi2A, "TransformationType");
point,0
Phi3 := Transformation(E, E, [x = -2*u[1] + x, u[] = -u[1]^2 + u[], u[1] = u[1]]);
Φ3≔x=−2⁢u1+x,u=−u12+u,u1=u1
Phi3A := AssignTransformationType(Phi3);
Phi3A≔x=−2⁢u1+x,u=−u12+u,u1=u1
DGinfo(Phi3A, "TransformationType");
"AbstractForms": the list of forms defined in an abstract frame.
DGsetup([[sigma1, sigma2, sigma3], tau = dgform(2), xi = dgform(3)], [], P):
DGinfo(P, "AbstractForms");
σ1,σ2,σ3,τ,ξ
ExteriorDerivative(tau);
d⁢τ
σ1,σ2,σ3,τ,ξ,d⁢τ
Hook(D_sigma1, xi);
ι1⁢ξ
Hook([D_sigma2, D_sigma3], xi);
ι2,3⁢ξ
σ1,σ2,σ3,τ,ξ,d⁢τ,ι1⁢ξ,ι2⁢ξ,ι2,3⁢ξ
"CoefficientGrading": the grading of the coefficients in a Lie algebra with coefficients
DGsetup(Alg, rho, AlgV):
DGinfo(AlgV, "CoefficientGrading");
table⁡w2=−3,w5=−1,w3=−2,w4=−1,w1=−3
DGinfo(AlgV, "CoefficientGrading", output = "list");
−3,−3,−2,−1,−1
DGinfo(output = "coefficients", "CoefficientGrading");
w1−3,w2−3,w3−2,w4−1,w5−1
"CoframeLabels": list the labels used to input and display the basis of 1-forms for the cotangent space.
DGinfo(M, "CoframeLabels");
dx,,dy,,dz,
F := FrameData([y*dx, z*dy, dz], N);
F≔d⁢Θ1=−Θ1⁢⋀⁢Θ2y⁢z,d⁢Θ2=−Θ2⁢⋀⁢Θ3z,d⁢Θ3=0
DGsetup(F, [X], [omega]):
DGinfo(N, "CoframeLabels");
omega1,,omega2,,omega3,
DGinfo(E, "CoframeLabels");
dx,,dy,,du,,du,1,du,2,du,1,1,du,1,2,du,2,2
L1 := _DG([["LieAlgebra", Alg1, [4]], [[[2, 4, 1], 1], [[3, 4, 3], 1]]]);
L1≔e2,e4=e1,e3,e4=e3
DGsetup(L1):
DGinfo(Alg1, "CoframeLabels");
theta1,,theta2,,theta3,,theta4,
"CurrentFrame": the name of the currently active frame.
DGsetup([x], M): DGsetup([y], N):
DGinfo("CurrentFrame");
LieBracket(D_x, x*D_x);
D_x
"ExteriorDerivativeFormStructureEquations": list the formulas for the exterior derivatives of a frame with protocol "LieAlgebra" or "AnholonomicFrame".
DGinfo("ExteriorDerivativeFormStructureEquations");
DGinfo(N, "ExteriorDerivativeFormStructureEquations");
−ω1y⁢z⁢⋀⁢ω2,−ω2z⁢⋀⁢ω3,0⁢ω1⁢⋀⁢ω2
DGinfo(Alg1, "ExteriorDerivativeFormStructureEquations");
−θ2⁢⋀⁢θ4,0⁢θ1⁢⋀⁢θ2,−θ3⁢⋀⁢θ4,0⁢θ1⁢⋀⁢θ2
"ExteriorDerivativeFunctionStructureEquations": list the formulas for the exterior derivatives of the coordinate functions for a frame with protocol or "moving_frame".
DGinfo("ExteriorDerivativeFunctionStructureEquations");
DGsetup([x, y, z], M): F := FrameData([y*dx, z*dy, dz], N);
DGinfo(N, "ExteriorDerivativeFunctionStructureEquations");
ω1y,ω2z,ω3
DGinfo(Alg1, "ExteriorDerivativeFunctionStructureEquations");
"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.
DGinfo(M, "FrameBaseDimension");
DGinfo(E, "FrameBaseDimension");
DGinfo(Alg1, "FrameBaseDimension");
"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.
DGinfo(M, "FrameBaseForms");
dx,dy,dz
DGinfo(N, "FrameBaseForms");
ω1,ω2,ω3
DGinfo(E, "FrameBaseForms");
dx,dy
DGinfo(Alg1, "FrameBaseForms");
θ1,θ2,θ3,θ4
"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.
DGinfo(M, "FrameBaseVectors");
D_x,D_y,D_z
DGsetup(F, [W], [omega]):
DGinfo(N, "FrameBaseVectors");
W1,W2,W3
DGinfo(E, "FrameBaseVectors");
D_x,D_y
DGinfo(Alg1, "FrameBaseVectors");
e1,e2,e3,e4
"FrameDependentVariables": the dependent or fiber variables for a frame defining a bundle E -> M.
DGinfo(M, "FrameDependentVariables");
DGsetup([x, y, z], [u, v], E):
DGsetup([x, y, z], [u, v], J, 1):
"FrameFiberDimension": the dimension of the fiber for a frame defining a bundle E -> M.
DGinfo(M, "FrameFiberDimension");
DGinfo(E, "FrameFiberDimension");
DGinfo(J, "FrameFiberDimension");
"FrameFiberForms": the coordinate basis of vertical 1-forms for a fiber bundle E -> M.
DGinfo(M, "FrameFiberForms");
Example 2
DGinfo(E, "FrameFiberForms");
du,dv
Example 3
DGinfo(J, "FrameFiberForms");
"FrameFiberVectors": the coordinate basis of vertical vectors for a fiber bundle E -> M.
DGinfo(M, "FrameFiberVectors");
DGinfo(E, "FrameFiberVectors");
D_u,D_v
DGinfo(J, "FrameFiberVectors");
"FrameGlobals": the list of Maple names that are assigned or protected when a frame is defined using the DGsetup command.
DGinfo(M, "FrameGlobals");
M,x,y,z,dx,dy,dz,D_x,D_y,D_z
F := FrameData([y*dx, z*dy, dz],N);
DGinfo(N, "FrameGlobals");
N,x,y,z,ω1,ω2,ω3,W1,W2,W3
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
DGinfo(Alg1, "FrameGlobals");
Alg1,_z14,_z15,_z16,_z17,θ1,θ2,θ3,θ4,e1,e2,e3,e4
"FrameHorizontalBiforms": the list of horizontal biforms on a jet space
DGinfo(M, "FrameHorizontalBiforms");
DGinfo(J, "FrameHorizontalBiforms");
Dx,Dy,Dz
"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.
DGinfo(M, "FrameIndependentVariables");
x,y,z
Omega := evalDG([y*dx, z*dy, dz]);
Ω≔y⁢dx,z⁢dy,dz
F := FrameData(Omega, N);
DGinfo(N, "FrameIndependentVariables");
DGinfo(E, "FrameIndependentVariables");
x,y
DGinfo(Alg1, "FrameIndependentVariables");
_z14,_z15,_z16,_z17
"FrameInformation": a complete display of all information pertaining to a given frame.
DGinfo(M, "FrameInformation");
library name: CoordinateProtocol
Frame Variables:
Frame Labels
Coframe Labels
--------------
DGinfo(N, "FrameInformation");
frame name: N
library name: AnholonomicFrameProtocol
ext_d:,x,ω1y
ext_d:,y,ω2z
ext_d:,z,ω3
ext_d:,ω1,−ω1y⁢z⁢⋀⁢ω2
ext_d:,ω2,−ω2z⁢⋀⁢ω3
ext_d:,ω3,0⁢ω1⁢⋀⁢ω2
DGinfo(E, "FrameInformation");
frame name: E
x,y,u,u1,u2,u1,1,u1,2,u2,2
D_x,D_y,D_u,D_u1,D_u2,D_u1,1,D_u1,2,D_u2,2
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
DGinfo(Alg1, "FrameInformation");
frame name: Alg1
library name: LieAlgebraProtocol
ext_d:,θ1,−θ2⁢⋀⁢θ4
ext_d:,θ2,0⁢θ1⁢⋀⁢θ2
ext_d:,θ3,−θ3⁢⋀⁢θ4
ext_d:,θ4,0⁢θ1⁢⋀⁢θ2
"FrameJetDimension": the total dimension of the frame.
DGinfo(M, "FrameJetDimension");
DGsetup([x, y, z], [u, v], N):
DGinfo(N, "FrameJetDimension");
5
DGinfo(J, "FrameJetDimension");
11
DGinfo(Alg1, "FrameJetDimension");
"FrameJetForms": the basis of all 1-forms for the frame.
DGinfo(M, "FrameJetForms");
DGinfo(N, "FrameJetForms");
dx,dy,dz,du,dv
DGsetup([x, y], [u], J, 2):
DGinfo(J, "FrameJetForms");
DGinfo(Alg1, "FrameJetForms");