@c -----------------------------------------------------------------------------
@c File        : Atensor.de.texi
@c License     : GNU General Public License (GPL)
@c Language    : German
@c Original    : Atensor.texi revision 14.03.2011
@c Translation : Dr. Dieter Kaiser
@c Date        : 14.11.2010
@c Revision    : 28.09.2011
@c 
@c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
@c -----------------------------------------------------------------------------

@c -----------------------------------------------------------------------------
@page
@node Paket atensor, , Paket ctensor, Tensoren
@section Paket @sc{atensor}
@c -----------------------------------------------------------------------------

@menu
* Einf@"uhrung in atensor::
* Funktionen und Variablen f@"ur atensor::
@end menu

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in atensor, Funktionen und Variablen f@"ur atensor, Paket atensor, Paket atensor
@subsection Einf@"uhrung in @sc{atensor}
@c -----------------------------------------------------------------------------

@c @code{atensor} is an algebraic tensor manipulation package. To use 
@c @code{atensor}, type @code{load("atensor")}, followed by a call to the 
@c @code{init_atensor} function.

Das Paket @code{atensor} erlaubt das algebraische Rechnen mit Tensoren.  Mit
dem Kommando @code{load("atensor")} wird das Paket geladen.  Um das Paket zu
initialisieren, wird die Funktion @mref{init_atensor} ausgef@"uhrt.

@c The essence of @code{atensor} is a set of simplification rules for the
@c noncommutative (dot) product operator ("@code{.}"). @code{atensor} recognizes
@c several algebra types; the corresponding simplification rules are put
@c into effect when the @code{init_atensor} function is called.

Im wesentlichen enth@"alt das Paket @code{atensor} Regeln f@"ur die
Vereinfachung von Ausdr@"ucken mit dem @mxref{dot, dot-Operator} Operator
@code{"."}.  @code{atensor} kennt verschiedene Algebren.  Mit der Funktion
@code{init_atensor} werden die Regeln einer Algebra initialisiert.

@c The capabilities of @code{atensor} can be demonstrated by defining the
@c algebra of quaternions as a Clifford-algebra Cl(0,2) with two basis
@c vectors. The three quaternionic imaginary units are then the two
@c basis vectors and their product, i.e.:

Um die M@"oglichkeiten des Paketes @code{atensor} zu zeigen, wird im Folgenden
die Algebra der Quaternionen als eine Clifford-Algebra Cl(0,2) mit zwei
Basisvektoren definiert.  Die drei imagin@"aren Einheiten @code{i}, @code{j}
und @code{k} werden durch die zwei Vektoren @code{v[1]} und @code{v[2]} sowie
das Produkt @code{v[1] . v[2]} dargestellt:

@example
    i = v     j = v     k = v  . v
         1         2         1    2
@end example

@c Although the @code{atensor} package has a built-in definition for the
@c quaternion algebra, it is not used in this example, in which we
@c endeavour to build the quaternion multiplication table as a matrix:

Das Paket @code{atensor} hat eine vordefinierte Algebra der Quaternionen.  Hier
wird die Algebra der Quaterinonen als Clifford-Algebra Cl(0,2) definiert und
die Multiplikationstabelle der Basisvektoren konstruiert.

@example
(%i1) load("atensor")$

(%i2) init_atensor(clifford,0,0,2);
(%o2)                         done
(%i3) atensimp(v[1].v[1]);
(%o3)                          - 1
(%i4) atensimp((v[1].v[2]).(v[1].v[2]));
(%o4)                          - 1
(%i5) q:zeromatrix(4,4);
                         [ 0  0  0  0 ]
                         [            ]
                         [ 0  0  0  0 ]
(%o5)                    [            ]
                         [ 0  0  0  0 ]
                         [            ]
                         [ 0  0  0  0 ]
(%i6) q[1,1]:1;
(%o6)                           1
(%i7) for i thru adim do q[1,i+1]:q[i+1,1]:v[i];
(%o7)                         done
(%i8) q[1,4]:q[4,1]:v[1].v[2];
(%o8)                        v  . v
                              1    2
(%i9) for i from 2 thru 4 do
          for j from 2 thru 4 do
              q[i,j]:atensimp(q[i,1].q[1,j]);
(%o9)                         done
(%i10) q;
            [    1        v         v      v  . v  ]
            [              1         2      1    2 ]
            [                                      ]
            [   v         - 1     v  . v    - v    ]
            [    1                 1    2      2   ]
(%o10)      [                                      ]
            [   v      - v  . v     - 1      v     ]
            [    2        1    2              1    ]
            [                                      ]
            [ v  . v      v        - v       - 1   ]
            [  1    2      2          1            ]
@end example

@c @code{atensor} recognizes as base vectors indexed symbols, where the symbol
@c is that stored in @code{asymbol} and the index runs between 1 and
@c @code{adim}.  For indexed symbols, and indexed symbols only, the bilinear
@c forms @code{sf}, @code{af}, and @code{av} are evaluated. The evaluation
@c substitutes the value of @code{aform[i,j]} in place of @code{fun(v[i],v[j])}
@c where @code{v} represents the value of @code{asymbol} and @code{fun} is
@c either @code{af} or @code{sf}; or, it substitutes @code{v[aform[i,j]]}
@c in place of @code{av(v[i],v[j])}.

Indizierte Symbole mit dem Namen, der in der Optionsvariablen @mref{asymbol}@w{}
abgelegt ist, werden von @code{atensor} als Basisvektoren erkannt.  Dabei
l@"auft der Index von @code{1} bis @mrefdot{adim}  F@"ur indizierte Symbole
werden die Bilinearformen @mrefcomma{sf} @mref{af} und @mref{av} ausgewertet.
Die Auswertung ersetzt die Bilinearform @code{fun(v[i].v[j])}, durch das
Matrixelement @code{aform[i,j]}, wobei @code{v} einen Basisvektor bezeichnet
und @code{fun} einer der Bilinearformen @code{sf} oder @code{af} ist.  Ist
@code{fun} die Bilinearform @code{av}, dann wird @code{v[aform[i,j]]} f@"ur
@code{av(v[i],v[j])} substituiert.  Siehe auch die Optionsvariable
@mrefdot{aform}

@c Needless to say, the functions @code{sf}, @code{af} and @code{av}
@c can be redefined.

Die Bilinearformen @code{sf}, @code{af} und @code{av} k@"onnen vom Nutzer
neu definiert werden, um eine gew@"unschte Algebra zu definieren.

@c When the @code{atensor} package is loaded, the following flags are set:

Wird das Paket @code{atensor} geladen, werden die folgenden Schalter auf die
angegebenen Werte gesetzt:

@example
dotscrules  : true
dotdistrib  : true
dotexptsimp : false
@end example

@c If you wish to experiment with a nonassociative algebra, you may also
@c consider setting @code{dotassoc} to @code{false}. In this case, however,
@c @code{atensimp} will not always be able to obtain the desired
@c simplifications.

Wird das symbolische Rechnen in einer nicht-assoziativen Algebra gew@"unscht,
kann auch noch der Schalter @mref{dotassoc} auf den Wert @code{false} gesetzt
werden.  In diesem Fall kann jedoch die Funktion @mref{atensimp} nicht immer
eine gew@"unschte Vereinfachung erzielen.

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur atensor, , Einf@"uhrung in atensor, Paket atensor
@subsection Funktionen und Variablen f@"ur @sc{atensor}
@c -----------------------------------------------------------------------------

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{init_atensor}
@deffn  {Funktion} init_atensor (@var{alg_type}, @var{opt_dims})
@deffnx {Funktion} init_atensor (@var{alg_type})

@c Initializes the @code{atensor} package with the specified algebra type.
@c @var{alg_type} can be one of the following:

Initialisiert das Paket @code{atensor} mit der angegebenen Algebra
@var{alg_type}.  Das Argument @var{alg_type} kann einen der folgenden
Werte haben:

@table @code
@item universal
@c The universal algebra has no commutation rules.
Eine allgemeine Algebra, f@"ur die keine Vertauschungsregeln definiert sind.

@item grassmann
@c The Grassman algebra is defined by the commutation
@c relation @code{u.v+v.u=0}.
Eine Gra@ss{}mann-Algebra, f@"ur die die Vertauschungsregel @code{u.v + v.u = 0}
definiert ist.

@item clifford
@c The Clifford algebra is defined by the commutation
@c relation @code{u.v+v.u=-2*sf(u,v)} where @code{sf} is a symmetric
@c scalar-valued function. For this algebra, @var{opt_dims} can be up
@c to three nonnegative integers, representing the number of positive,
@c degenerate, and negative dimensions of the algebra, respectively. If
@c any @var{opt_dims} values are supplied, @code{atensor} will configure the
@c values of @code{adim} and @code{aform} appropriately. Otherwise,
@c @code{adim} will default to 0 and @code{aform} will not be defined.
Eine Clifford-Algebra, die durch die Vertauschungsregel @code{u.v + v.u =
-2*sf(u,v)} definiert ist.  Die Bilinearform @mref{sf} ist eine symmetrische
Funktion, die einen skalaren Wert als Ergebnis hat.  Das Argument @var{opt_dims}
kann bis zu drei positive ganze Zahlen sein, die die positiven, 
entarteten und negativen Dimensionen der Algebra bezeichnen.  Die Dimension
@mref{adim} und die Matrix @mref{aform} werden entsprechend der angegebenen
Argumente @var{opt_dims} initialisiert.  Sind keine Argumente @var{opt_dims}
vorhanden, wird die Dimension @code{adim} zu Null initialisiert und keine
Matrix @code{aform} definiert.

@item symmetric
@c The symmetric algebra is defined by the commutation
@c relation @code{u.v-v.u=0}.
Eine symmetrische Algebra, die durch die Vertauschungsregel @code{u.v - v.u = 0}
definiert ist.

@item symplectic
@c The symplectic algebra is defined by the commutation
@c relation @code{u.v-v.u=2*af(u,v)} where @code{af} is an antisymmetric
@c scalar-valued function. For the symplectic algebra, @var{opt_dims} can
@c be up to two nonnegative integers, representing the nondegenerate and
@c degenerate dimensions, respectively. If any @var{opt_dims} values are
@c supplied, @code{atensor} will configure the values of @code{adim} and 
@c @code{aform} appropriately. Otherwise, @code{adim} will default to 0 and 
@c @code{aform} will not be defined.
Eine symplektische Algebra, die durch die Vertauschungsregel
@code{u.v - v.u = 2*af(u,v)} definiert ist.  Die Bilinearform @mref{af} ist
eine antisymmetrische Funktion, die einen skalaren Wert als Ergebnis hat.  Das 
Argument @var{opt_dims} kann bis zu zwei positive ganze Zahlen enthalten,
die die nicht-degenerierten und degenerierten Dimensionen der Algebra
bezeichnen.  Die Dimension @mref{adim} und die Matrix @mref{aform}@w{}
werden entsprechend der angegebenen Argumente @var{opt_dims} initialisiert.
Sind keine Argumente @var{opt_dims} vorhanden, wird die Dimension @code{adim}
zu Null initialisiert und keine Matrix @code{aform} definiert. 

@item lie_envelop
@c The algebra of the Lie envelope is defined by the
@c commutation relation @code{u.v-v.u=2*av(u,v)} where @code{av} is
@c an antisymmetric function.
Eine einh@"ullende Lie-Algebra, die durch die Vertauschungsregel
@code{u.v - v.u = 2*av(u,v)} definiert ist, wobei die Bilinearform @mref{av}@w{}
eine antisymmetrische Funktion ist.  Das Argument @var{opt_dims} kann eine
positive ganze Zahl sein, welche die Dimension der Lie-Algebra angibt.  Die
Dimension @mref{adim} und die Matrix @mref{aform} werden entsprechend des
Argumentes @var{opt_dims} initialisiert.  Ist kein Argument @var{opt_dims}
vorhanden, wird die Dimension @code{adim} zu Null initialisiert und keine Matrix
@code{aform} definiert.
@end table

@c The @code{init_atensor} function also recognizes several predefined
@c algebra types:

Die Funktion @code{init_atensor} kennt weiterhin einige vordefinierte
Algebren:

@table @code
@item complex
@c implements the algebra of complex numbers as the
@c Clifford algebra Cl(0,1). The call @code{init_atensor(complex)} is
@c equivalent to @code{init_atensor(clifford, 0, 0, 1)}.
Die Algebra der komplexen Zahlen, die als eine Clifford-Algebra Cl(0,1)
definiert wird.  Das Kommando @code{init_atensor(complex)} ist @"aquivalent zum
Kommando @code{init_atensor(clifford, 0, 0, 1)}.

@item quaternion
@c implements the algebra of quaternions. The call
@c @code{init_atensor (quaternion)} is equivalent to
@c @code{init_atensor (clifford, 0, 0, 2)}.
Die Algebra der Quaternionen, die als eine Clifford-Algebra vom Typ Cl(0,2)
definiert wird.  Das Kommando @code{init_atensor(quaternion)}
ist @"a@-qui@-va@-lent zum Kommando @code{init_atensor(clifford, 0, 0, 2)}.

@item pauli
@c implements the algebra of Pauli-spinors as the Clifford-algebra
@c Cl(3,0). A call to @code{init_atensor(pauli)} is equivalent to
@c @code{init_atensor(clifford, 3)}.
Die Algebra der Pauli-Matrizen, die als eine Clifford-Algebra Cl(3,0)
definiert wird.  Das Kommando @code{init_atensor(pauli)} ist @"aquivalent
zum Kommando @code{init_atensor(clifford, 3)}.

@item dirac
@c implements the algebra of Dirac-spinors as the Clifford-algebra
@c Cl(3,1). A call to @code{init_atensor(dirac)} is equivalent to
@c @code{init_atensor(clifford, 3, 0, 1)}.
Die Algebra der Dirac-Matrizen, die als eine Clifford-Algebra Cl(3,0,1)
definiert wird.  Das Kommando @code{init_atensor(dirac)} ist @"aquivalent zum
Kommando @code{init_atensor(clifford, 3, 0, 1)}.
@end table
@end deffn

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{atensimp}
@deffn {Funktion} atensimp (@var{expr})

@c Simplifies an algebraic tensor expression @var{expr} according to the rules
@c configured by a call to @code{init_atensor}. Simplification includes
@c recursive application of commutation relations and resolving calls
@c to @code{sf}, @code{af}, and @code{av} where applicable. A
@c safeguard is used to ensure that the function always terminates, even
@c for complex expressions.

Vereinfacht einen Ausdruck @var{expr} entsprechend der Regeln f@"ur die Algebra,
die mit der Funktion @mref{init_atensor} festgelegt ist.  Die Regeln werden
rekursiv auf den Ausdruck angewendet.  Dabei werden auch Bilinearformen
@mrefcomma{sf} @mref{af} und @mref{av} ausgewertet.

Beispiele:

Die folgenden Beispiele zeigen das Rechnen mit der Algebra der Quaternionen.

@example
(%i1) load("atensor")$

(%i2) init_atensor(quaternion);
(%o2)                         done
(%i3) atensimp(v[1].v[1]);
(%o3)                          - 1
(%i4) atensimp(v[2].v[2]);
(%o4)                          - 1
(%i5) atensimp((v[1].v[2]) . (v[1].v[2]));
(%o5)                          - 1
(%i6) expand((2*v[1]+3*v[2])^^2);
(%o6) 9 (v  . v ) + 6 (v  . v ) + 6 (v  . v ) + 4 (v  . v )
          2    2        2    1        1    2        1    1
(%i7) atensimp(%);
(%o7)                         - 13
@end example
@end deffn

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{alg_type}
@defvr {Optionsvariable} alg_type
Standardwert: @code{universal}

@c The algebra type.  Valid values are @code{universal}, @code{grassmann},
@c @code{clifford}, @code{symmetric}, @code{symplectic} and @code{lie_envelop}.

Der Typ der Algebra, die bei der Vereinfachung von Ausdr@"ucken mit der
Funktion @mref{atensimp} angewendet wird.  Die Algebra wird von der Funktion
@code{init_atensor} initialisiert.  M@"ogliche Algebren sind @code{universal},
@code{grassmann}, @code{clifford}, @code{symmetric}, @code{symplectic} und
@code{lie_envelop}.  Siehe f@"ur eine ausf@"uhrliche Erl@"auterung der Algebren
die Funktion @mrefdot{init_atensor}
@end defvr

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{adim}
@defvr {Optionsvariable} adim
Standardwert: @code{0}

@c The dimensionality of the algebra.  @code{atensor} uses the value of
@c @code{adim} to determine if an indexed object is a valid base vector.  See
@c @code{abasep}.

Die Dimension der Algebra, die bei der Vereinfachung von Ausdr@"ucken mit der
Funktion @mref{atensimp} angewendet wird.  Die Dimension wird von der Funktion
@mref{init_atensor} initialisiert.  Ein indiziertes Symbol mit dem Bezeichner
@mref{asymbol} ist dann ein Basisvektor, wenn der Index kleiner oder gleich
der Dimension @code{adim} ist.

Beispiel:

Die Dirac-Algebra hat die Dimension @code{4} und @code{v[4]} ist ein
Basisvektor.

@example
(%i1) load("atensor")$

(%i2) init_atensor(dirac);
(%o2)                         done
(%i3) adim;
(%o3)                           4
(%i4) abasep(v[4]);
(%o4)                         true
@end example
@end defvr

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{aform}
@defvr {Optionsvariable} aform
Standardwert: @code{ident(3)}

@c Default values for the bilinear forms @code{sf}, @code{af}, and
@c @code{av}.  The default is the identity matrix @code{ident(3)}.

Matrix mit den Werten der Bilinearformen @mrefcomma{sf} @mref{af} und
@mrefdot{av}  Der Standardwert ist die dreidimensionale Einheitsmatrix.

Beispiel:

Das Beispiel zeigt die Matrix @code{aform} f@"ur eine Lie-Algebra mit drei
Dimensionen und die Ergebnisse der Bilinearform @code{av} f@"ur diese Algebra.

@example
(%i1) load("atensor")$

(%i2) init_atensor(lie_envelop, 3);
(%o2)                         done
(%i3) aform;
                        [  0    3   - 2 ]
                        [               ]
(%o3)                   [ - 3   0    1  ]
                        [               ]
                        [  2   - 1   0  ]
(%i4) av(v[1], v[2]);
(%o4)                          v
                                3
(%i5) av(v[1], v[3]);
(%o5)                         - v
                                 2
@end example
@end defvr

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{asymbol}
@defvr {Optionsvariable} asymbol
Standardwert: @code{v}

@c The symbol for base vectors.

Enth@"alt das Symbol, das einen Basisvektor des Paketes @code{atensor}
bezeichnet.  Mit der Funktion @mref{abasep} kann getestet werde, ob ein
indiziertes Symbol einen Basisvektor der Algebra bezeichnet.

Beispiel:

In diesem Beispiel wird @code{asymbol} auf den Wert @code{x} gesetzt.

@example
(%i1) load("atensor")$

(%i2) init_atensor(symmetric, 2);
(%o2)                         done
(%i3) asymbol;
(%o3)                           v
(%i4) abasep(v[2]);
(%o4)                         true
(%i5) asymbol: x;
(%o5)                           x
(%i6) abasep(x[2]);
(%o6)                         true
@end example
@end defvr

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{sf}
@deffn {Funktion} sf (@var{u}, @var{v})

@c A symmetric scalar function that is used in commutation relations.
@c The default implementation checks if both arguments are base vectors
@c using @code{abasep} and if that is the case, substitutes the
@c corresponding value from the matrix @code{aform}.

Eine symmetrische Bilinearform, die bei der Vereinfachung von Ausdr@"ucken
mit der Funktion @mref{atensimp} angewendet wird.  Die Funktion kann vom Nutzer
durch eine neue Funktion ersetzt werden.  Die Standardimplementation pr@"uft
mit der Funktion @mrefcomma{abasep} ob die Argumente @var{u} und @var{v}
Basisvektoren sind und setzt f@"ur diesen Fall den entsprechen Wert der Matrix
@mref{aform} ein.
@end deffn

@c -----------------------------------------------------------------------------
@anchor{af}
@deffn {Funktion} af (@var{u}, @var{v})

@c An antisymmetric scalar function that is used in commutation relations.
@c The default implementation checks if both arguments are base vectors
@c using @code{abasep} and if that is the case, substitutes the
@c corresponding value from the matrix @code{aform}.

Eine antisymmetrische Bilinearform, die bei der Vereinfachung von Ausdr@"ucken
mit der Funktion @mref{atensimp} angewendet wird.  Die Funktion kann vom Nutzer
durch eine neue Funktion ersetzt werden.  Die Standardimplementation pr@"uft
mit der Funktion @mrefcomma{abasep} ob die Argumente @var{u} und @var{v}
Basisvektoren sind und setzt f@"ur diesen Fall den entsprechenden Wert der
Matrix @mref{aform} ein.
@end deffn

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{av}
@deffn {Funktion} av (@var{u}, @var{v})

@c An antisymmetric function that is used in commutation relations.
@c The default implementation checks if both arguments are base vectors
@c using @code{abasep} and if that is the case, substitutes the
@c corresponding value from the matrix @code{aform}.

Eine antisymmetrische Bilinearform, die bei der Vereinfachung von Ausdr@"ucken
mit der Funktion @mref{atensimp} angewendet wird.  Die Funktion kann vom Nutzer
durch eine neue Funktion ersetzt werden.  Die Standardimplementation pr@"uft
mit der Funktion @mrefcomma{abasep} ob die Argumente @var{u} und @var{v}
Basisvektoren sind und setzt f@"ur diesen Fall den entsprechenden Wert
@code{v[aform[i,j]]} der Matrix @mref{aform} ein.

Beispiel:

@example
(%i1) load("atensor")$
(%i2) adim: 3;
(%o2)                           3
(%i3) aform:matrix([0,3,-2],[-3,0,1],[2,-1,0]);
                        [  0    3   - 2 ]
                        [               ]
(%o3)                   [ - 3   0    1  ]
                        [               ]
                        [  2   - 1   0  ]
(%i4) asymbol: x;
(%o4)                           x
(%i5) av(x[1], x[2]);
(%o5)                          x
                                3
(%i6) av(x[1], x[3]);
(%o6)                         - x
                                 2
@end example
@end deffn

@c --- 28.09.2011 DK -----------------------------------------------------------
@anchor{abasep}
@deffn {Funktion} abasep (@var{v})

@c Checks if its argument is an @code{atensor} base vector. That is, if it is
@c an indexed symbol, with the symbol being the same as the value of
@c @code{asymbol}, and the index having a numeric value between 1
@c and @code{adim}.

Pr@"uft, ob das Argument @var{v} ein Basisvektor ist.  Ein Basisvektor ist ein
indiziertes Symbol mit dem Symbol @mref{asymbol} als Bezeichner und einem
Index im Bereich von @code{1} bis @mrefdot{adim}

Beispiel:

@example
(%i1) load("atensor")$
(%i2) asymbol: x$
(%i3) adim:3$
(%i4) abasep(x[1]);
(%o4)                         true
(%i5) abasep(x[3]);
(%o5)                         true
(%i6) abasep(x[4]);
(%o6)                         false
@end example
@end deffn

@c --- End of file Atensor.de.texi ---------------------------------------------

