See the attached worksheet for one proof that the surface is indeed flat.

Surface.mw

Hello Agharabo.  Below you will find a link to a worksheet showing how to use DifferentialGeometry to construct the Lie group in your example and to define its Lie algebra using invariant vector fields.  

Note that the DifferentialGeometry package includes a comprehensive collection of Lessons and Tutorials, which may be of some help as you get to know the package.

Agharabo_LieGroups.mw

The Lie derivative of a function h:M -> R along a vector field v on M, is the directional derivative of the function h along v.  Assuming your space is M = R^3 with coordinates (x, y, L) and that the "vector valued function" is given in components in the coordinates (x, y, L) (with u and v playing the role of parameters), then the following will calculate the Lie derivative.  (Get help on DifferentialGeometry[LieDerivative] for more information.)

with(DifferentialGeometry):

DGsetup([x, y, L], R3);

h := sqrt((y-x)^2 + L^2);

f := evalDG((x+u)*D_x + (y+v)*D_y + L*D_L);

LieDerivative(f, h);

The LieAlgebraData command cannot be used to construct your algebra since the dual quaternions do not form a Lie algebra.  The dual quaternions are a Clifford algebra; such algebras can be initialized with the AlgebraLibraryData command.

AlgebraLibraryData("Clifford(3)" , alg);

Note that this command accepts a keyword argument quadraticform which may be needed to arrive at the desired structure equations.

Q := LinearAlgebra:-DiagonalMatrix([1,1,-1]);
AlgebraLibraryData("Clifford(3)", alg, quadraticform = Q);

I hope this helps.

Hello.

For future reference, have a look at the command DifferentialGeometry:-LieAlgebras:-LieAlgebraData.  One of the uses of that command is to compute all the Lie brackets of a list of vector fields.  Their multiplication table can then be displayed using DifferentialGeometry:-DGsetup and the DifferentialGeometry:-LieAlgebras:-MultiplicationTable commands. 

I have edited your worksheet to show how to compute the covariant derivatives of the function, as you requested.  I have also shown how to build the d'Alembertian.   The edited worksheet is attached to this message. 

On_edited.mw

One way to do this is via the DifferentialGeometry command GetComponents.  

In your example you would use

GetComponents(T, [D_x, D_y])

to get a list consisting of the x and y components. See the GetComponents help page for details.

In the version of DifferentialGeometry you are using, the operation of contraction only occurs among tensors.  The Christoffel symbol is, strictly speaking, not a tensor but a connection.  To compute the quantity you are after, you should first convert the Christoffel symbol to a tensor. For example.

with(DifferentialGeometry):

with(Tensor):

DGsetup([r, phi], M);

g := evalDG(dr &t dr+ r^2 * dphi &t dphi);

C := convert(Christoffel(g), DGtensor);

ContractIndices(C, D_phi, [[2, 1]]);

To compute the Riemannian connection you must specify the metric tensor.  Which do you want to use?  Are you using the usual metric of Euclidean space?  If so, I don't think your manual computation is correct. (The directional derivative of e3 along e1 vanishes using the Euclidean connection.) Anyway, I am attaching a worksheet which shows how to calculate the Koszul formula using the standard differential geometry tools which are contained in the DifferentialGeometry package. 

Koszul.mw

One approach to doing what you want is as follows.

First, view the connection coefficients as components of a tensor (relative to the zero connection) using.

T := convert(C2, DGtensor);

Next, extract the desired components in the usual tensorial way, by evaluating the tensor on appropriate basis elements.  For example, to get the component T^t_xy use 

evalDG(T, [D_t, dx, dy]);

I hope this helps.

To change coordinates within DifferentialGeometry you must first construct the tensor via the DifferentialGeometry commands (see evalDG and AlgebraicOperations help pages in DifferentialGeometry). Then you create a transformation as you have done in your post.  Then you use the commands Pullback and/or PushPullTensor; see their help files for details and examples. 

I have uploaded a worksheet (attached at the bottom) which shows one approach to answering your question.

The definition of curl of a rank 2 tensor you provided is only valid in a Cartesian coordinate system. The reason is that the partial differentiation operation of any tensor is something which is normally tied to a specific coordinate system. In addition, the tensor contraction between the permutation symbol and the derivative of the tensor needs to be generalized to curvilinear coordinates.

And there are some minor additional issues. (1) In curvilinear coordinates one has an option to use a "coordinate basis" (also called holonomic basis) to express tensors, or one can use an "orthonormal basis" (or, more generally, an anholonomic basis). All these basis choices coalesce in Cartesian coordinates. (2) One has to decide what is the "type" of the rank two tensor. It can be contravariant, or covariant, or mixed. All 3 types coalesce in Cartesian coordinates.

So, you can see that the generalization to other coordinate systems requires us to make some choices.

The simplest generalization of the curl - and probably the one you want - would be to replace the partial differentiation with the covariant derivative defined by a metric and to use that metric to make the contractions. It is this generalization I will use. In the following I will show how to compute this "curl" in cylindrical coordinates, but the strategy will work in any coordinates. I will show how to do it for a contravariant tensor in either a coordinate basis or in an orthonormal basis. The tools being used reside in the DifferentialGeometry package and its Tensor sub-package.

Disclaimer: I typed this up in a hurry - beware of typos.

Curl_of_a_tensor.mw

Since your Lie algebra is semi-simple there is an alternative strategy for its decomposition using the structure theory of semi-simple Lie algebras. Try the following steps.

(1) Call your initialized Lie algebra alg. Compute a Cartan subalgebra. 

> CSA := CartanSubalgebra(alg)

(2) Calculate the associated root space decomposition.

> RSD := RootSpaceDecomposition(CSA) 

(3) Calculate the positive roots.

> PR := PositiveRoots(RSD)

Depending on the structure of the root space decomposition, you may need to use one of the alternate calling sequences to compute the positive roots. See the help page for PositiveRoots.

(4) Calculate the simple roots

> SR := SimpleRoots(PR)

 (5) Calculate the Cartan matrix

 > CM := CartanMatrix(SR, RSD)

(6) If necessary, rearrange the order of the simple roots (in the list SR) so that the Cartan matrix in step (5) is block diagonal, with each block a Cartan matrix in standard form.  See the CartanMatrix help page for the standard forms. 

(7) The original Lie algebra is then the direct sum of simple Lie algebras corresponding to each block in CM from step (6).

 (8) If desired, using the simple roots obtained in step (6) and the root space decomposition, one can find a new basis for the original Lie algebra which is adapted to this direct sum decomposition.  

 In an upcoming update to the DifferentialGeometry software steps (6), (7), (8) are automated.

The tensor g you created is not a symmetric tensor and so it is not a metric.  That is what the Christoffel command is complaining about.  It appears that all you need to do is to symmetrize your tensor products. The simplest way to do this is to replace the tensor products &t with the symmetric tensor products &s everywhere in your definition of g.

charlie

One way to do this is to use the TensorInnerProduct command from the DifferentialGeometry package and its Tensor sub-package. I have attached a worksheet which shows how.

Kretschmann.mw