simpLB

 

  
Purpose 		
 
Simplify a Lie bracket according to the property of distributivity
over scalar multiplication, and return the scalar part and the
simplified pure Lie bracket.





Syntax 		 
xs:=simpLB(x);




Description 		 

The command simpLB simplifies any Lie bracket based on the
distributivity over scalar multiplication property.  This command
returns the scalar terms of the Lie bracket grouped together
multiplying a Lie monomial (i.e. a Lie bracket containing only generators of the Lie algebra without any
scalar coefficients).


This function returns a list (a Maple sequence) of three elements: the
simplified bracket in the form $\textit{scalar}*\textit{pure
 bracket}$, the $\textit{scalar}$ part, the $\textit{pure bracket}$,
in the first, second and third positions of the list.  The elements in
the list can be accessed individually by appending the index selector
after the name of the output variable or after the invocation of the
function, i.e. if  xs:=simpLB(x), then xs[2] corresponds
to the second element in the output list stored in xs.
Similarly if only the second element is required, simpLB can be
invoked as z:=simpLB(x)[2]; in this case z does not
contain a list but only the second element of the list produced by
simpLB.





Arguments 		 
$x$  Any Lie bracket.




Examples 		 

As an example consider the simplification of $[\alpha f_2,[\alpha f_1,
(\alpha+\beta^2) f_0 ] ] )$, which should return the scalar part
$(\alpha^3+\alpha^2\beta^2)$ and the pure bracket $[f_2,[f_1,f_0]]$.
This can be easily achieved as follows:
> x:=(a*f2) &* ((a*f1) &* ((a+b^2)*f0));
                                        2
      x := a~ f2~ &* (a~ f1~ &* (a~ + b~ ) f0~)
> z:=simpLB(x);
        3     2   2                           2         2
z := (a~  + a~  b~ ) (f2~ &* (f1~ &* f0~)), a~  (a~ + b~ ),

      f2~ &* (f1~ &* f0~)
> z[3];
                  f2~ &* (f1~ &* f0~)





Algorithm 		 

The algorithm behind the implementation of this function is
illustrated in the flow chart of Fig. 11.


The main idea is to decompose each element in the Lie product into its
scalar and vector (Lie indeterminate) part.  If there is no Lie
product operator &* standing between the operands, simply the
scalar and vector parts are returned, otherwise the function
recursively calls itself to further decompose the operands into scalar
and vector parts.  As shown in the bottom right process box of the
flow chart in Fig. 11, the scalar part of $x$ is the
multiplication of the scalar parts of the left and right operands of
$x$, while the pure bracket of $x$ is the multiplication in
the Lie product of the left and right pure operands of $x$,
which are also obtained by calling simpLB with the respective
operand as an argument, thus simpLB calls itself until no
Lie product operator &* is found.  

Figure 11: Flow chart for the simpLB function.