[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20. Tensoren


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.1 Tensorpakete in Maxima

Maxima hat drei verschiedene Pakete, um mit Tensoren zu rechnen. Das Paket ctensor implementiert das Rechnen mit Tensoren in der Koordinatendarstellung und das Paket itensor das Rechnen in einer Indexnotation. Das Paket atensor erlaubt die algebraische Manipulation von Tensoren in verschiedenen Algebren.

Beim Rechnen in einer Koordinatendarstellung mit dem Paket ctensor werden Tensoren als Arrays oder Matrizen dargestellt. Operationen mit Tensoren wie die Tensorverjüngung oder die kovariante Ableitung werden ausgeführt als Operationen mit den Komponenten des Tensors, die in einem Array oder einer Matrix gespeichert sind.

Beim Rechnen in der Indexnotation mit dem Paket itensor werden Tensoren als Funktionen ihrer kovarianten und kontravarianten Indizes sowie den Ableitungen nach den Komponenten dargestellt. Operationen wie die Tensorverjüngung oder die kovariante Ableitung werden ausgeführt, in dem die Indizes manipuliert werden.

Die beiden genannten Pakete itensor und ctensor für die Behandlung von mathematischen Problemen im Zusammenhang mit der Riemannschen Geometrie haben verschiedene Vor- und Nachteile, die sich erst anhand des zu behandelnden Problems und dessen Schwierigkeitsgrad zeigen. Folgenden Eigenschaften der beiden Implementierungen sollten beachtet werden:

Die Darstellung von Tensoren und Tensoroperationen in einer expliziten Koordinatendarstellung vereinfacht die Nutzung des Paketes ctensor. Die Spezifikation der Metrik und die Ableitung von Tensoren sowie von Invarianten ist unkompliziert. Trotz Maximas Methoden für die Vereinfachung von Ausdrücken kann jedoch eine komplexe Metrik mit komplizierten funktionalen Abhängigkeiten der Koordinaten leicht zu sehr großen Ausdrücken führen, die die Struktur eines Ergebnisses verbergen. Weiterhin können Rechnungen zu sehr großen Zwischenergebnisse führen, die zu einem Programmabbruch führen, bevor die Rechnung beendet werden kann. Jedoch kann der Nutzer mit einiger Erfahrung viele dieser Probleme vermeiden.

Aufgrund der besonderen Weise, wie Tensoren und Tensoroperationen als symbolische Operationen ihrer Indizes dargestellt werden, können Ausdrücke, die in einer Koordinatendarstellung sehr unhandlich sind, mit Hilfe spezieller Routinen für symmetrische Objekte in itensor manchmal erheblich vereinfacht werden. Auf diese Weise kann die Struktur großer Ausdrücke transparenter sein. Auf der anderen Seite kann die Spezifikation einer Metrik, die Definition von Funktionen und die Auswertung von abgeleiteten indizierten Objekten für den Nutzer schwierig sein.

Mit dem Paket itensor können Ableitungen nach einer indizierten Variablen ausgeführt werden, wodurch es möglich ist, itensor auch für Probleme im Zusammenhang mit dem Lagrange- oder Hamiltonian-Formalismus einzusetzen. Da es möglich ist, die Lagrangeschen Feldgleichungen nach einer indizierten Variablen abzuleiten, können zum Beispiel die Euler-Lagrange-Gleichungen in einer Indexnotation aufgestellt werden. Werden die Gleichungen mit der Funktion ic_convert in eine Komponentendarstellung für das Paket ctensor transformiert, können die Feldgleichungen in einer bestimmten Koordinatendarstellung gelöst werden. Siehe dazu die ausführlichen Beispiele in einhil.dem und bradic.dem.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2 Paket ITENSOR


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.1 Einführung in ITENSOR

Das Paket itensor für das Rechnen mit Tensoren in der Indexnotation wird mit dem Kommando load(itensor) geladen. Mit dem Kommando demo(tensor) wird eine Liste mit verschiedenen Beispielen angezeigt.

Im Paket itensor werden Tensoren als indiziertes Objekte dargestellt. Ein indiziertes Objekt ist eine Funktion mit drei Gruppen an Indizes, die die kovarianten, kontravarianten und Ableitungsindizes eines Tensors darstellen. Das erste Argument der Funktion ist eine Liste der kovarianten Indizes und das zweite Argument die Liste der kontravarianten Indizes. Hat der Tensor keine entsprechenden Komponenten, dann wird eine leere Liste als Argument angegeben. Zum Beispiel repräsentiert g([a,b], [c] einen Tensor g, der zwei kovariante Indizes [a,b], einen kontravarianten Index [c] und keinen Ableitungsindex hat. Mit der Funktion ishow werden Tensoren in einer besonderen Schreibweise ausgegeben.

Beispiele:

(%i1) load(itensor)$

(%i2) g([a,b], [c]);
(%o2)                    g([a, b], [c])

(%i3) ishow(g([a,b], [c]))$
                               c
(%t3)                         g
                               a b

Ableitungsindizes werden als weitere Argumente der Funktion hinzugefügt, die den Tensor repräsentiert. Ableitungsindizes können vom Nutzer angegeben oder bei der Ableitung von Tensoren von Maxima hinzugefügt werden. Im Allgemeinen ist die Differentiation kommutativ, so dass die Reihenfolge der Ableitungsindizes keine Rolle spielt. Daher werden die Indizes von Maxima bei der Vereinfachung mit Funktionen wie rename alphabetisch sortiert. Dies ist jedoch nicht der Fall, wenn bewegte Bezugssysteme genutzt werden, was mit der Optionsvariablen iframe_flag angezeigt wird, die in diesem Fall den Wert true erhält. Es ist zu beachten, dass mit dem Paket itensor Ableitungsindizes nicht angehoben werden können und nur als kovariante Indizes auftreten.

Beispiele:

(%i1) load(itensor)$

(%i2) ishow(t([a,b],[c],j,i))$
                             c
(%t2)                       t
                             a b,j i
(%i3) ishow(rename(%))$
                             c
(%t3)                       t
                             a b,i j
(%i4) ishow(t([a,b],[c],j,i) - t([a,b],[c],i,j))$
                        c          c
(%t4)                  t        - t
                        a b,j i    a b,i j
(%i5) ishow(rename(%))$
(%t5)                           0
(%i6) iframe_flag:true;
(%o6)                         true
(%i7) ishow(t([a,b],[c],j,i) - t([a,b],[c],i,j))$
                        c          c
(%t7)                  t        - t
                        a b,j i    a b,i j
(%i8) ishow(rename(%))$
                        c          c
(%t8)                  t        - t
                        a b,j i    a b,i j

Das folgende Beispiel zeigt einen Ausdruck mit verschiedenen Ableitungen eines Tensors g. Ist g der metrische Tensor, dann entspricht das Ergebnis der Definition des Christoffel-Symbols der ersten Art.

(%i1) load(itensor)$

(%i2) ishow(1/2*(idiff(g([i,k],[]),j) + idiff(g([j,k],[]),i) 
                                      - idiff(g([i,j],[]),k)))$
                    g      + g      - g
                     j k,i    i k,j    i j,k
(%t2)               ------------------------
                               2

Tensoren werden standardmäßig nicht als symmetrisch angenommen. Erhält die Optionsvariable allsym den Wert true, dann werden alle Tensoren als symmetrisch in den kovarianten und kontravarianten Indizes angenommen.

Das Paket itensor behandelt Tensoren im Allgemeinen als opake Objekte. Auf Tensorgleichungen werden algebraischen Regeln insbesondere Symmetrieregeln und Regeln für die Tensorverjüngung angewendet. Weiterhin kennt itensor die kovariante Ableitung, Krümmung und die Torsion. Rechnungen können in bewegten Bezugssystemen ausgeführt werden.

Beispiele:

Die folgenden Beispiele zeigen einige Anwendungen des Paketes itensor.

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) imetric(g);
(%o2)                                done
(%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$
(%i4) ishow(g([k,l],[]))$
(%t4)                               e p
                                       k l
(%i5) ishow(diff(v([i],[]),t))$
(%t5)                                  0
(%i6) depends(v,t);
(%o6)                               [v(t)]
(%i7) ishow(diff(v([i],[]),t))$
                                    d
(%t7)                               -- (v )
                                    dt   i
(%i8) ishow(idiff(v([i],[]),j))$
(%t8)                                v
                                      i,j
(%i9) ishow(extdiff(v([i],[]),j))$
(%t9)                             v    - v
                                   j,i    i,j
                                  -----------
                                       2
(%i10) ishow(liediff(v,w([i],[])))$
                               %3          %3
(%t10)                        v   w     + v   w
                                   i,%3    ,i  %3
(%i11) ishow(covdiff(v([i],[]),j))$
                                              %4
(%t11)                        v    - v   ichr2
                               i,j    %4      i j
(%i12) ishow(ev(%,ichr2))$
                %4 %5
(%t12) v    - (g      v   (e p       + e   p     - e p       - e    p
        i,j            %4     j %5,i    ,i  j %5      i j,%5    ,%5  i j

                                         + e p       + e   p    ))/2
                                              i %5,j    ,j  i %5
(%i13) iframe_flag:true;
(%o13)                               true
(%i14) ishow(covdiff(v([i],[]),j))$
                                             %6
(%t14)                        v    - v   icc2
                               i,j    %6     i j
(%i15) ishow(ev(%,icc2))$
                                             %6
(%t15)                        v    - v   ifc2
                               i,j    %6     i j
(%i16) ishow(radcan(ev(%,ifc2,ifc1)))$
             %6 %7                    %6 %7
(%t16) - (ifg      v   ifb       + ifg      v   ifb       - 2 v
                    %6    j %7 i             %6    i j %7      i,j

                                             %6 %7
                                        - ifg      v   ifb      )/2
                                                    %6    %7 i j
(%i17) ishow(canform(s([i,j],[])-s([j,i])))$
(%t17)                            s    - s
                                   i j    j i
(%i18) decsym(s,2,0,[sym(all)],[]);
(%o18)                               done
(%i19) ishow(canform(s([i,j],[])-s([j,i])))$
(%t19)                                 0
(%i20) ishow(canform(a([i,j],[])+a([j,i])))$
(%t20)                            a    + a
                                   j i    i j
(%i21) decsym(a,2,0,[anti(all)],[]);
(%o21)                               done
(%i22) ishow(canform(a([i,j],[])+a([j,i])))$
(%t22)                                 0

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2 Funktionen und Variablen für ITENSOR


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.1 Behandlung indizierter Größen

Funktion: canten (expr)

Ist vergleichbar mit der Funktion rename und vereinfacht den Ausdruck expr indem gebundene Indizes umbenannt und permutiert werden. Wie die Funktion rename kann canten nur Ausdrücke mit Summen von Tensorprodukten vereinfachen, in denen keine Ableitungen nach Tensorkomponenten auftreten. Daher sollte canten nur verwendet werden, wenn sich mit der Funktion canform nicht die gewünschte Vereinfachung eines Ausdrucks erzielen lässt.

Das Ergebnis der Funktion canten ist mathematisch nur korrekt, wenn die Tensoren symmetrisch in ihren Indizes sind. Hat die Optionsvariable allsym nicht den Wert true, bricht canten mit einer Fehlermeldung ab.

Siehe auch die Funktion concan, mit der Ausdrücke mit Tensoren ebenfalls vereinfacht werden können, wobei concan zusätzlich Tensorverjüngungen ausführt.

Funktion: changename (old, new, expr)

Ändert den Namen aller Tensoren im Ausdruck expr von old nach new. Das Argument old kann ein Symbol oder eine Liste der Form [name, m, n] sein. Im letzteren Fall werden nur die Tensoren zu new umbenannt, die den Namen name sowie m kovariante und n kontravariante Indizes haben.

Beispiel:

In diesem Beispiel wird der Name c zu w geändert.

(%i1) load(itensor)$

(%i2) expr:a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e$

(%i3) ishow(changename(c, w, expr))$
                                  k
(%t3)                 d e w    + a    b
                           x y    i j  u,v

Funktion: components (tensor, expr)

Erlaubt die Zuweisung von Werten an die Komponenten eines Tensors tensor, die mit dem Argument expr angegeben werden. Immer wenn der Tensor tensor mit all seinen Indizes in einem Ausdruck auftritt, werden die Komponenten mit den angegebenen Werten substituiert. Der Tensor muss die Form t([...],[...]) haben, wobei die Listen auch leer sein können. Das Argument expr ist irgendein Ausdruck, der dieselben freien Indizes wie der Tensor tensor hat. Sollen Werte an einen Metriktensor zugewiesen werden, der Dummy-Indizes hat, so muss auf die Benennung der Indizes sorgfältig geachtet werden, um das Auftreten von Mehrfachen Dummy-Indizes zu vermeiden. Mit der Funktion remcomps werden Zuweisungen der Funktion components an die Komponenten eines Tensors entfernt.

Es muss beachtet werden, dass die Funktion components nur den Typ eines Tensors, aber nicht die Ordnung der Indizes beachtet. Werden daher Werte an die Komponenten der Tensoren x([i,-j],[]), x([-j,i],[]) oder x([i],[j]) zugewiesen, ergibt sich jeweils dasselbe Ergebnis.

Komponenten können einem indizierten Ausdruck auf vier verschiedene Methoden zugeordnet werden. Zwei Methoden nutzen die Funktion components.

1) Als ein indizierte Ausdruck:

(%i2) components(g([],[i,j]), e([],[i])*p([],[j]))$
(%i3) ishow(g([],[i,j]))$
                                      i  j
(%t3)                                e  p

2) Als eine Matrix:

(%i5) lg:-ident(4)$ lg[1,1]:1$ lg;
                            [ 1   0    0    0  ]
                            [                  ]
                            [ 0  - 1   0    0  ]
(%o5)                       [                  ]
                            [ 0   0   - 1   0  ]
                            [                  ]
                            [ 0   0    0   - 1 ]

(%i6) components(g([i,j],[]), lg);
(%o6)                                done
(%i7) ishow(g([i,j],[]))$
(%t7)                                g
                                      i j
(%i8) g([1,1],[]);
(%o8)                                  1
(%i9) g([4,4],[]);
(%o9)                                 - 1

3) Als eine Funktion: Die Werte der Komponenten eines Tensors werden durch eine Funktion gegeben.

(%i4) h(l1,l2,[l3]):=if length(l1)=length(l2) and length(l3)=0
  then kdelta(l1,l2) else apply(g,append([l1,l2], l3))$
(%i5) ishow(h([i],[j]))$
                                          j
(%t5)                               kdelta
                                          i
(%i6) ishow(h([i,j],[k],l))$
                                     k
(%t6)                               g
                                     i j,l

4) Mit Mustern und Regeln: Im Folgenden wird ein Beispiel mit den Funktionen defrule und applyb1 gezeigt.

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) matchdeclare(l1,listp);
(%o2)                                done
(%i3) defrule(r1,m(l1,[]),(i1:idummy(),
      g([l1[1],l1[2]],[])*q([i1],[])*e([],[i1])))$

(%i4) defrule(r2,m([],l1),(i1:idummy(),
      w([],[l1[1],l1[2]])*e([i1],[])*q([],[i1])))$

(%i5) ishow(m([i,n],[])*m([],[i,m]))$
                                    i m
(%t5)                              m    m
                                         i n
(%i6) ishow(rename(applyb1(%,r1,r2)))$
                           %1  %2  %3 m
(%t6)                     e   q   w     q   e   g
                                         %1  %2  %3 n

Funktion: concan (expr)

Ist vergleichbar mit der Funktion canten. Im Unterschied zu canten werden zusätzlich Tensorverjüngungen ausgeführt.

Funktion: contract (expr)

Führt die Tensorverjüngungen im Ausdruck expr aus, die beliebige Summen und Produkte sein können. contract nutzt die Informationen, die für die Tensoren mit der Funktion defcon definiert sind. Die besten Ergebnisse werden erzielt, wenn der Ausdruck expr vollständig expandiert wird. Die Funktion radexpand expandiert Produkte und Potenzen von Summen am schnellsten, sofern keine Variablen im Nenner der Terme auftreten. Die Optionsvariable gcd sollte den Wert false haben, wenn das Kürzen durch einen größten gemeinsamen Teiler nicht notwendig ist.

Systemvariable: contractions

Die Liste contractions enthält die Tensoren, die mit der Funktion defcon die Eigenschaft einer Tensorverjüngung erhalten haben.

Funktion: defcon (tensor_1)
Funktion: defcon (tensor_1, tensor_2, tensor_3)

Gibt einem Tensor tensor_1 die Eigenschaft, dass die Tensorverjüngung des Produktes tensor_1 mit tensor_2 das Ergebnis tensor_3 hat. Wird nur ein Argument tensor_1 angegeben, dann hat die Tensorverjüngung für jeden Tensor tensor, der die korrekten Indizes hat, das Ergebnis tensor mit neuen Indizes, die die Tensorverjüngung widerspiegeln.

Wird zum Beispiel die Metrik als imetric: g gesetzt, dann wird mit defcon(g) das Hochstellen und Herunterstellen der Indizes mit dem Metriktensor definiert.

Wird defcon wiederholt für einen Tensor aufgerufen, ist jeweils die letzte Definition wirksam.

Die Liste contractions enthält die Tensoren, die mit der Funktion defcon die Eigenschaft einer Tensorverjüngung erhalten haben.

Funktion: dispcon (tensor_1, tensor_2, …)
Funktion: dispcon (all)

Zeigt die Kontraktionseigenschaften der Tensoren tensor_1, tensor_2, … wie sie mit der Funktion defcon definiert wurden. Das Kommando dispcon(all) zeigt alle vom Nutzer definierten Kontraktionseigenschaften.

Beispiel:

Wird das Paket itensor geladen, gibt dispcon das folgende Ergebnis.

(%i1) load(itensor)$

(%i2) dispcon(all);
(%o2)      [[[ifr, ifri, ifg]], [[ifg, ifg, kdelta]]]

Funktion: entertensor (name)

Die Funktion entertensor ermöglicht die Eingabe eines indizierten Tensors mit einer beliebigen Anzahl an Tensorindizes und Ableitungen. Es kann ein einzelner Index oder eine Liste mit Indizes angegeben werden. Die Liste kann eine leere Liste sein.

Beispiel:

(%i1) load(itensor)$

(%i2) entertensor()$
Enter tensor name: a;
Enter a list of the covariant indices: [i,j];
Enter a list of the contravariant indices: [k];
Enter a list of the derivative indices: [];
                               k
(%t2)                         a
                               i j

Optionsvariable: flipflag

Standardwert: false

Hat die Optionsvariable flipflag den Wert false, werden die Indizes von der Funktion rename bei der Umbenennung in der Reihenfolge der kontravarianten Indizes sortiert, ansonsten in der Reihenfolge der kovarianten Indizes.

Siehe auch das Beispiel für die Funktion rename.

Optionsvariable: icounter

Standardwert: 0

Enthält die laufende Nummer, um den nächsten Dummy-Index zu bilden. icounter wird automatisch erhöht, bevor der neue Index gebildet wird. Dem Wert icounter wird er Präfix idummyx vorangestellt. Der Standardwert von idummyx ist %.

Funktion: idummy ()

Erhöht den Wert der laufenden Nummer icounter und gibt einen neuen Index zurück, indem der Präfix idummyx der Nummer icounter vorangestellt wird. Siehe auch die Funktion indices.

Optionsvariable: idummyx

Standardwert: %

Enthält den Präfix, der einem neuen Index vorangestellt wird, der mit der Funktion idummy gebildet wird.

Funktion: indexed_tensor (tensor)

Muss ausgeführt werden, bevor einem Tensors tensor Komponenten zugewiesen werden, für die bereits interne Werte vorliegen wie für ichr1, ichr2 oder icurvature. Siehe das Beispiel zur Funktion icurvature.

Funktion: indices (expr)

Gibt eine Liste mit zwei Elementen zurück. Das erste Element ist eine Liste mit den Indizes im Ausdruck expr die frei sind, also nur einmal auftreten. Das zweite Elemente ist eine Liste mit den Indizes, über die summiert wird, die also im Ausdruck genau zweimal auftreten.

Ein Tensorprodukt mit einem Index der mehr als zweimal auftritt, ist nicht korrekt formuliert. Die Funktion indices gibt in einem solchen Fall jedoch keinen Fehler aus.

Beispiel:

(%i1) load(itensor)$

(%i2) ishow(a([i,j],[k,l],m,n)*b([k,o],[j,m,p],q,r))$
                         k l      j m p
(%t2)                   a        b
                         i j,m n  k o,q r
(%i3) indices(%);
(%o3)          [[l, p, i, n, o, q, r], [k, j, m]]

Funktion: ishow (expr)

Zeigt den Ausdruck expr an, wobei Tensoren im Ausdruck mit tiefgestellten kovarianten Indizes und hochgestellten kontravarianten Indizes sowie die Ableitungen mit durch ein Komma getrennten tiefgestellte Indizes angezeigt werden.

Beispiel:

(%i1) load(itensor)$

(%i2) ishow(a([i,j], [k], v,w))$
                             k
(%t2)                       a
                             i j,v w

Funktion: kdels (L1, L2)

kdels gibt wie die Funktion kdelta ein Kronecker-Delta zurück. Im Unterschied zu kdelta ist das Kronecker-Delta der Funktion kdels symmetrisch.

Beispiele:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) kdelta([1,2],[2,1]);
(%o2)                                 - 1
(%i3) kdels([1,2],[2,1]);
(%o3)                                  1
(%i4) ishow(kdelta([a,b],[c,d]))$
                             c       d         d       c
(%t4)                  kdelta  kdelta  - kdelta  kdelta
                             a       b         a       b
(%i4) ishow(kdels([a,b],[c,d]))$
                             c       d         d       c
(%t4)                  kdelta  kdelta  + kdelta  kdelta
                             a       b         a       b

Funktion: kdelta (L1, L2)

Ist das verallgemeinerte Kronecker-Delta im itensor-Paket. Das Argument L1 ist die Liste der kovarianten und L2 der kontravarianten Indizes. kdelta([i],[j]) gibt das einfache Kronecker-Delta zurück.

Das itensor-Paket erlaubt die Definition des Kronecker-Delta nur mit kovarianten oder kontravarianten Indizes, wie zum Beispiel kdelta([i,j],[]). Mit diesen Größen kann gerechnet werden, sie sind jedoch keine Tensoren.

Regel: lc_l

lc_l ist eine Regel, um Ausdrücke zu vereinfachen, die Levi-Civita-Symbole enthalten. Zusammen mit der Regel lc_u kann die Regel zum Beispiel mit der Funktion applyb1 angewendet werden, um Ausdrücke effizienter zu vereinfachen, als durch eine Auswertung des Symbols levi_civita.

Beispiele:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) el1:ishow('levi_civita([i,j,k],[])*a([],[i])*a([],[j]))$
                             i  j
(%t2)                       a  a  levi_civita
                                             i j k
(%i3) el2:ishow('levi_civita([],[i,j,k])*a([i])*a([j]))$
                                       i j k
(%t3)                       levi_civita      a  a
                                              i  j
(%i4) canform(contract(expand(applyb1(el1,lc_l,lc_u))));
(%t4)                                  0
(%i5) canform(contract(expand(applyb1(el2,lc_l,lc_u))));
(%t5)                                  0

Regel: lc_u

lc_u ist eine Regel, um Ausdrücke zu vereinfachen, die Levi-Civita-Symbole enthalten. Zusammen mit der Regel lc_c kann die Regel zum Beispiel mit der Funktion applyb1 angewendet werden, um Ausdrücke effizienter zu vereinfachen, als durch eine Auswertung des Symbols levi_civita. Siehe lc_l für Beispiele.

Funktion: lc2kdt (expr)

Vereinfacht den Ausdruck expr mit Levi-Civita-Symbolen. Wenn möglich werden diese zu Kronecker-Delta-Symbolen vereinfacht. Im Unterschied zu der Auswertung eines Ausdrucks mit Levi-Civita-Symbolen, vermeidet die Funktion lc2kdt das Einführen von numerischen Indizes, die für eine weitere symbolische Vereinfachung zum Beispiel mit den Funktionen rename oder contract nicht geeignet sind.

Beispiel:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) expr:ishow('levi_civita([],[i,j])
                 *'levi_civita([k,l],[])*a([j],[k]))$
                                  i j  k
(%t2)                  levi_civita    a  levi_civita
                                       j            k l
(%i3) ishow(ev(expr,levi_civita))$
                                  i j  k       1 2
(%t3)                       kdelta    a  kdelta
                                  1 2  j       k l
(%i4) ishow(ev(%,kdelta))$
             i       j         j       i   k
(%t4) (kdelta  kdelta  - kdelta  kdelta ) a
             1       2         1       2   j

                               1       2         2       1
                        (kdelta  kdelta  - kdelta  kdelta )
                               k       l         k       l
(%i5) ishow(lc2kdt(expr))$
                     k       i       j    k       j       i
(%t5)               a  kdelta  kdelta  - a  kdelta  kdelta
                     j       k       l    j       k       l
(%i6) ishow(contract(expand(%)))$
                                 i           i
(%t6)                           a  - a kdelta
                                 l           l

Die Funktion lc2kdt benötigt in einigen Fällen den Metriktensor. Ist der Metriktensor zuvor nicht mit der Funktion imetric definiert, dann meldet Maxima einen Fehler.

(%i7) expr:ishow('levi_civita([],[i,j])
                 *'levi_civita([],[k,l])*a([j,k],[]))$
                                 i j            k l
(%t7)                 levi_civita    levi_civita    a
                                                     j k
(%i8) ishow(lc2kdt(expr))$
Maxima encountered a Lisp error:

 Error in $IMETRIC [or a callee]:
 $IMETRIC [or a callee] requires less than two arguments.

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.
(%i9) imetric(g);
(%o9)                                done
(%i10) ishow(lc2kdt(expr))$
         %3 i       k   %4 j       l     %3 i       l   %4 j
(%t10) (g     kdelta   g     kdelta   - g     kdelta   g    
                    %3             %4               %3
              k
        kdelta  ) a
              %4   j k
(%i11) ishow(contract(expand(%)))$
                                  l i    l i  j
(%t11)                           a    - g    a
                                              j

Funktion: levi_civita (L)

Ist der Levi-Civita-Tensor, der auch Permutationstensor genannt wird. Der Tensor hat den Wert 1, wenn die Liste L eine gerade Permutation ganzer Zahlen ist, den Wert -1 für eine ungerade Permutation und ansonsten den Wert 0.

Beispiel:

Für eine Kreisbewegung ist die Bahngeschwindigkeit v das Kreuzprodukt aus Winkelgeschwindigkeit w und Ortsvektor r. Wir haben also v = w x r. Hier wird eine tensorielle Schreibweise des Kreuzproduktes mit dem Levi-Civita-Tensor eingeführt. Der Ausdruck wird sodann für die erste Komponente zu der bekannten Definition des Kreuzproduktes vereinfacht.

(%i1) load(itensor)$

(%i2) ishow(v([],[a])=
           'levi_civita([],[a,b,c])*w([b],[])*r([c],[]))$
                    a              a b c
(%t2)              v  = levi_civita      w  r
                                          b  c
(%i3) ishow(subst([a=1],%))$
                    1              1 b c
(%t3)              v  = levi_civita      w  r
                                          b  c
(%i4) ishow(ev(%, levi_civita))$
                      1         1 b c
(%t4)                v  = kdelta      w  r
                                1 2 3  b  c
(%i5) ishow(expand(ev(%, kdelta)))$
        1         b       c               c       b
(%t5)  v  = kdelta  kdelta  w  r  - kdelta  kdelta  w  r
                  2       3  b  c         2       3  b  c
(%i6) ishow(contract(%))$
                        1
(%t6)                  v  = w  r  - r  w
                             2  3    2  3

In diesem Beispiel wird das Spatprodukt von drei Vektoren a, b und b mit dem Levi-Civita-Tensor definiert und dann vereinfacht.

(%i1) load(itensor)$

(%i2) ishow(levi_civita([],[i,j,k])*a([i],[])*b([j],[])*c([k],[]))$
                            i j k
(%t2)                 kdelta      a  b  c
                            1 2 3  i  j  k
(%i3) ishow(contract(expand(ev(%,kdelta))))$
(%t3) a  b  c  - b  a  c  - a  c  b  + c  a  b  + b  c  a
       1  2  3    1  2  3    1  2  3    1  2  3    1  2  3
                                                       - c  b  a
                                                          1  2  3

Funktion: listoftens (expr)

Gibt eine Liste mit allen Tensoren zurück, die im Argument expr enthalten sind.

Beispiel:

(%i1) load(itensor)$

(%i2) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
                                  k
(%t2)                 d e c    + a    b
                           x y    i j  u,v
(%i3) ishow(listoftens(%))$
                        k
(%t3)                 [a   , b   , c   , d]
                        i j   u,v   x y

Funktion: remcomps (tensor)

Entfernt alle Werte von den Komponenten des Tensors tensor, die einen Wert mit der Funktion components erhalten haben.

Funktion: remcon (tensor_1, …, tensor_n)
Funktion: remcon (all)

Entfernt die Eigenschaften der Tensorverjüngung von den Tensoren tensor_1, …, tensor_n. remcon(all) entfernt die Eigenschaften von der Tensorverjüngung für alle Tensoren. Das sind die Tensoren, die in der Liste contractions enthalten sind.

Funktion: rename (expr)
Funktion: rename (expr, count)

Gibt einen zum Argument expr äquivalenten Ausdruck zurück, wobei die Summationsindizes mit den Werten aus der liste [%1, %2, ...] umbenannt sind. Wird das zusätzlich das Argument count angegeben, wird die Nummerierung mit dem Wert count begonnen. Jeder Summationsindex in einem Produkt erhält einen verschiedenen Namen. Für eine Summe wird der Zähler für jeden Term zurückgesetzt. Auf diese Weise wirkt die Funktion rename wie eine Vereinfachung eines tensoriellen Ausdrucks. Hat die Optionsvariable allsym den Wert true, werden die Indizes alphabetisch nach den kovarianten oder kontravarianten Indizes geordnet, entsprechend dem Wert der Optionsvariablen flipflag. Hat die Optionsvariable flipflag den Wert true, werden die Indizes entsprechend der Ordnung der kovarianten Indizes geordnet. Es ist häufig der Fall, dass das Ordnen sowohl nach den kovarianten als auch den kontravarianten Indizes einen Ausdruck besser vereinfacht, als allein die Ordnung nach einer der Indizes.

Beispiele:

(%i1) load(itensor)$

(%i2) allsym: true;
(%o2)                         true
(%i3) g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%4],[%3])
             *ichr2([%2,%3],[u])*ichr2([%5,%6],[%1])
             *ichr2([%7,r],[%2])
 -g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%2],[u])
               *ichr2([%3,%5],[%1])*ichr2([%4,%6],[%3])
               *ichr2([%7,r],[%2])$

(%i4) expr: ishow(%)$
       %4 %5  %6 %7      %3         u          %1         %2
(%t4) g      g      ichr2      ichr2      ichr2      ichr2
                         %1 %4      %2 %3      %5 %6      %7 r
          %4 %5  %6 %7      u          %1         %3         %2
       - g      g      ichr2      ichr2      ichr2      ichr2
                            %1 %2      %3 %5      %4 %6      %7 r
(%i5) flipflag: true;
(%o5)                         true
(%i6) ishow(rename(expr))$
       %2 %5  %6 %7      %4         u          %1         %3
(%t6) g      g      ichr2      ichr2      ichr2      ichr2
                         %1 %2      %3 %4      %5 %6      %7 r
          %4 %5  %6 %7      u          %1         %3         %2
       - g      g      ichr2      ichr2      ichr2      ichr2
                            %1 %2      %3 %4      %5 %6      %7 r
(%i7) flipflag: false;
(%o7)                         false
(%i8) rename(%th(2));
(%o8)                           0
(%i9) ishow(rename(expr))$
       %1 %2  %3 %4      %5         %6         %7        u
(%t9) g      g      ichr2      ichr2      ichr2     ichr2
                         %1 %6      %2 %3      %4 r      %5 %7
          %1 %2  %3 %4      %6         %5         %7        u
       - g      g      ichr2      ichr2      ichr2     ichr2
                            %1 %3      %2 %6      %4 r      %5 %7

Funktion: showcomps (tensor)

Zeigt die Zuweisungen mit der Funktion components an die Komponenten des Tensors tensor. Die Funktion showcomps kann auch die Komponenten eines Tensors mit einer höheren Stufe als 2 zeigen.

Beispiel:

(%i1) load(ctensor)$
(%i2) load(itensor)$
(%i3) lg:matrix([sqrt(r/(r-2*m)),0,0,0],[0,r,0,0],
                [0,0,sin(theta)*r,0],[0,0,0,sqrt((r-2*m)/r)]);
               [         r                                     ]
               [ sqrt(-------)  0       0              0       ]
               [      r - 2 m                                  ]
               [                                               ]
               [       0        r       0              0       ]
(%o3)          [                                               ]
               [       0        0  r sin(theta)        0       ]
               [                                               ]
               [                                      r - 2 m  ]
               [       0        0       0        sqrt(-------) ]
               [                                         r     ]
(%i4) components(g([i,j],[]),lg);
(%o4)                                done
(%i5) showcomps(g([i,j],[]));
                  [         r                                     ]
                  [ sqrt(-------)  0       0              0       ]
                  [      r - 2 m                                  ]
                  [                                               ]
                  [       0        r       0              0       ]
(%t5)      g    = [                                               ]
            i j   [       0        0  r sin(theta)        0       ]
                  [                                               ]
                  [                                      r - 2 m  ]
                  [       0        0       0        sqrt(-------) ]
                  [                                         r     ]
(%o5)                                false

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.2 Tensorsymmetrien

Optionsvariable: allsym

Standardwert: false

Hat die Optionsvariable allsym den Wert true, werden alle indizierten Größen als symmetrisch in ihren kovarianten und kontravarianten Indizes angenommen. Ist der Wert false, werden keine Symmetrien für die Indizes angenommen. Die Indizes von Ableitungen werden immer als symmetrisch angenommen, außer wenn die Optionsvariable iframe_flag den Wert true hat.

Funktion: decsym (tensor, m, n, [cov_1, cov_2, …], [contr_1, contr_2, …])

Definiert Symmetrieeigenschaften für den Tensor tensor mit m kovarianten und n kontravarianten Indizes. Die Argumente cov_i und contr_i geben Symmetrieeigenschaften zwischen den kontravarianten und kontravarianten Indizes an. Die Argumente haben die Form symoper(index_1, index_2, .... symoper ist einer der Symmetrieeigenschaften sym für symmetrisch, anti für antisymmetrisch oder cyc für zyklisch und die Argumente index_i sind ganze Zahlen, die die Position des Index im Tensor tensor angegeben. Weiterhin ist die Form symoper(all) möglich. In diesem Fall wird die entsprechende Symmetrieeigenschaft für alle Indizes angenommen.

Ist zum Beispiel b ein Tensor mit 5 kovarianten Indizes, dann wird mit decsym(b, 5, 3, [sym(1,2), anti(3,4)], [cyc(all)]) definiert, dass b symmetrisch in den Indizes 1 und 2, antisymmetrisch in den Indizes 3 und 4 sowie zyklisch in allen kontravarianten Indizes ist.

Symmetrieeigenschaften, die mit der Funktion decsym definiert werden, werden von der Funktion canform angewendet.

Beispiele:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) expr:contract( expand( a([i1, j1, k1], [])
           *kdels([i, j, k], [i1, j1, k1])))$
(%i3) ishow(expr)$
(%t3)         a      + a      + a      + a      + a      + a
               k j i    k i j    j k i    j i k    i k j    i j k
(%i4) decsym(a,3,0,[sym(all)],[]);
(%o4)                                done
(%i5) ishow(canform(expr))$
(%t5)                              6 a
                                      i j k
(%i6) remsym(a,3,0);
(%o6)                                done
(%i7) decsym(a,3,0,[anti(all)],[]);
(%o7)                                done
(%i8) ishow(canform(expr))$
(%t8)                                  0
(%i9) remsym(a,3,0);
(%o9)                                done
(%i10) decsym(a,3,0,[cyc(all)],[]);
(%o10)                               done
(%i11) ishow(canform(expr))$
(%t11)                        3 a      + 3 a
                                 i k j      i j k
(%i12) dispsym(a,3,0);
(%o12)                     [[cyc, [[1, 2, 3]], []]]

Funktion: remsym (tensor, m, n)

Entfernt die Symmetrieeigenschaften des Tensors tensor, der m kovariante und n kontravariante Indizes hat.

Funktion: canform (expr)
Funktion: canform (expr, rename)

Vereinfacht den Ausdruck expr indem alle Dummy-Indizes umbenannt und umgeordnet werden, wobei vorhandene Symmetrieeigenschaften angewendet werden. Hat die Optionsvariable allsym den Wert true, werden alle Indizes als symmetrisch angenommen. Ansonsten werden Symmetrieeigenschaften angewendet, die mit der Funktion decsym definiert sind. Die Dummy-Indizes werden auf gleiche Weise umbenannt wie von der Funktion rename. Wird canform auf einen großen Ausdruck angewendet, kann die Ausführung eine lange Zeit beanspruchen. Die Rechenzeit kann verkürzt werden, indem zuerst die Funktion rename auf den Ausdruck angewendet wird.

canform kann einen Ausdruck nicht immer in die einfachste Form bringen, jedoch ist das Ergebnis immer mathematisch korrekt.

Erhält das optionale zweite Argument rename den Wert false, wird die Umbenennung mit der Funktion rename nicht ausgeführt.

Für ein Beispiel siehe die Funktion decsym.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.3 Tensoranalysis

Funktion: diff (expr, v_1, n_1, v_2, n_2, …)

Ist die gleichnamige Funktion diff für die Differentiation einer tensoriellen Größe. diff ist für das Paket itensor erweitert. Die tensorielle Größe expr wird n_1-mal nach der Variablen v_1, n_2 nach der Variablen v_2, … abgeleitet. Die Argumente v_1 können ganze Zahlen von 1, …, dim sein. In diesem Fall bezeichnen die ganzen Zahlen der Reihe nach die Indizes, die in der Optionsvariablen vect_coords abgelegt sind. dim ist die Dimension der tensoriellen Größen.

Weiterhin erlaubt die erweiterte Funktion diff die Berechnung von Ableitungen nach indizierten Variablen. So können Ausdrücke, die den Metriktensor und seine Ableitungen enthalten, nach dem Metriktensor und seinen Ableitungen abgeleitet werden.

Beispiele:

(%i1) load(itensor)$

(%i2) depends(v,t);
(%o2)                        [v(t)]
(%i3) ishow(diff(v([i,j],[k])^2, t,1))$
                          k    d    k
(%t3)                  2 v    (-- (v   ))
                          i j  dt   i j
(%i4) ishow(diff(v([i,j],[k])^2, t,2))$
                       2
                 k    d     k          d    k    2
(%t4)         2 v    (--- (v   )) + 2 (-- (v   ))
                 i j    2   i j        dt   i j
                      dt

Funktion: idiff (expr, v_1, [n_1, [v_2, n_2] …])

idiff führt Ableitungen nach den Koordinaten einer tensoriellen Größe aus. Im Unterschied dazu führt die Funktion diff Ableitungen nach den unabhängigen Variablen aus. Eine tensorielle Größe erhält zusätzlich den Index v_1, der die Ableitung bezeichnet. Mehrfache Indizes für Ableitungen werden sortiert, außer wenn die Optionsvariable iframe_flag den Wert true hat.

idiff kann auch die Determinante des Metriktensors ableiten. Wird zum Beispiel der Optionsvariablen imetric der Wert g zugewiesen, dann hat das Kommando idiff(determinant(g), k) das Ergebnis 2 * determinant(g) * ichr2([%i,k], [%i]), wobei die Dummy-Variable passend gewählt wird.

Funktion: liediff (v, ten)

Berechnet die Lie-Ableitung eines tensoriellen Ausdrucks ten für das Vektorfeld v. Das Argument ten kann irgendeine tensorielle Größe sein. Das Argument v ist der Name eines Vektorfeldes und wird ohne Indizes angegeben.

Beispiel:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) ishow(liediff(v,a([i,j],[])*b([],[k],l)))$
       k    %2            %2          %2
(%t2) b   (v   a       + v   a     + v   a    )
       ,l       i j,%2    ,j  i %2    ,i  %2 j

                          %1  k        %1  k      %1  k
                      + (v   b      - b   v    + v   b   ) a
                              ,%1 l    ,l  ,%1    ,l  ,%1   i j

Funktion: rediff (ten)

Wertet jedes Auftreten von Substantivformen der Funktion idiff in dem tensoriellem Ausdruck ten aus.

Funktion: undiff (expr)

Gibt einen zum Argument expr äquivalenten Ausdruck zurück, in dem alle Ableitungen von indizierten Größen durch Substantivformen der Funktion idiff ersetzt sind.

Funktion: evundiff (expr)

Ist äquivalent zur Ausführung der Funktion undiff, der die Funktionen ev und rediff nachfolgen.

evundiff erlaubt die Auswertung von Ausdrücken, die nicht direkt in ihrer abgeleiteten Form ausgewertet werden können. So führt das folgende Beispiel zu einer Fehlermeldung:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) icurvature([i,j,k],[l],m);
Maxima encountered a Lisp error:

 Error in $ICURVATURE [or a callee]:
 $ICURVATURE [or a callee] requires less than three arguments.

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.

Wird jedoch icurvature in der Substantivform verwendet, kann der Ausdruck mit evundiff ausgewertet werden:

(%i3) ishow('icurvature([i,j,k],[l],m))$
                                         l
(%t3)                          icurvature
                                         i j k,m
(%i4) ishow(evundiff(%))$
             l              l         %1           l           %1
(%t4) - ichr2        - ichr2     ichr2      - ichr2       ichr2
             i k,j m        %1 j      i k,m        %1 j,m      i k

             l              l         %1           l           %1
      + ichr2        + ichr2     ichr2      + ichr2       ichr2
             i j,k m        %1 k      i j,m        %1 k,m      i j

Um Christoffel-Symbole abzuleiten, wird die Funktion evundiff nicht benötigt:

(%i5) imetric(g);
(%o5)                                done
(%i6) ishow(ichr2([i,j],[k],l))$
       k %3
      g     (g         - g         + g        )
              j %3,i l    i j,%3 l    i %3,j l
(%t6) -----------------------------------------
                          2

                         k %3
                        g     (g       - g       + g      )
                         ,l     j %3,i    i j,%3    i %3,j
                      + -----------------------------------
                                         2

Funktion: flush (expr, tensor_1, tensor_2, …)

Alle tensoriellen Größen tensor_i die im Ausdruck expr auftreten und keine Ableitungen haben, werden zu Null gesetzt.

Funktion: flushd (expr, tensor_1, tensor_2, …)

Alle tensoriellen Größen tensor_i die im Ausdruck expr auftreten und Ableitungen haben, werden zu Null gesetzt.

Funktion: flushnd (expr, tensor, n)

Setzt alle Ableitungen der tensoriellen Größe tensor die im Ausdruck expr auftritt und n oder mehr Ableitungen hat, auf den Wert Null.

Beispiele:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) ishow(a([i],[J,r],k,r)+a([i],[j,r,s],k,r,s))$
                                J r      j r s
(%t2)                          a      + a
                                i,k r    i,k r s
(%i3) ishow(flushnd(%,a,3))$
                                     J r
(%t3)                               a
                                     i,k r

Funktion: coord (tensor_1, tensor_2, …)
Systemvariable: coord

Gibt der tensoriellen Größe tensor_i die Eigenschaft, dass die kovariante Ableitung eines Vektors mit dem Namen tensor_i das Ergebnis Kronecker-Delta hat.

coord ist auch eine Systemvariable, die alle tensoriellen Größen enthält, die mit der Funktion coord die Eigenschaft der kovarianten Ableitung erhalten haben.

Beispiel:

(%i1) coord(x);
(%o1)                         done
(%i2) idiff(x([],[i]),j);
(%o2)                   kdelta([j], [i])
(%i3) coord;
(%o3)                          [x]

Funktion: remcoord (tensor_1, tensor_2, …)
Funktion: remcoord (all)

Entfernt die mit der Funktion coord definierte Eigenschaft für die tensoriellen Größen tensor_i. Das Kommando remcoord(all) entfernt diese Eigenschaft für alle tensoriellen Größen.

Funktion: makebox (expr, name)

Zeigt das Argument expr auf die gleiche Weise an wie die Funktion ishow mit dem Unterschied, dass der d’Alembert-Operator name im Ausdruck durch [] ersetzt wird.

Beispiel:

(%i1) makebox(g([],[i,j])*p([m],[n],i,j),g);
(%o1)                     []p([m], [n])

Funktion: conmetderiv (expr, tensor)

Vereinfacht Ausdrücke, die kovariante und kontravariante Ableitungen des Metriktensors enthalten. conmetderiv kann zum Beispiel die Ableitungen des kontravarianten Metriktensors in Beziehung zu den Christoffel-Symbolen setzen:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) ishow(g([],[a,b],c))$
                                      a b
(%t2)                                g
                                      ,c
(%i3) ishow(conmetderiv(%,g))$
                         %1 b      a       %1 a      b
(%t3)                 - g     ichr2     - g     ichr2
                                   %1 c              %1 c

Funktion: simpmetderiv (expr)
Funktion: simpmetderiv (expr[, stop])

Vereinfacht Ausdrücke die Produkte von Ableitungen des Metriktensors enthalten. Im besonderen erkennt simpmetderiv die folgenden Identitäten:

   ab        ab           ab                 a
  g   g   + g   g     = (g   g  )   = (kdelta )   = 0
   ,d  bc        bc,d         bc ,d          c ,d

daher ist

   ab          ab
  g   g   = - g   g
   ,d  bc          bc,d

und

  ab          ab
 g   g     = g   g
  ,j  ab,i    ,i  ab,j

was aus den Symmetrien der Christoffel-Symbole folgt.

Die Funktion simpmetderiv akzeptiert einen optionalen Parameter stop. Ist dieser vorhanden, stoppt die Funktion nach der ersten erfolgreichen Substitution in einem Produkt. simpmetderiv beachtet ferner die Optionsvariable flipflag, welche die Ordnung der Indizes kontrolliert.

Siehe auch weyl.dem für Beispiele der Funktionen simpmetderiv und conmetderiv, die die Vereinfachung des Weyl-Tensors zeigen.

Beispiel:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) imetric(g);
(%o2)                                done
(%i3) ishow(g([],[a,b])*g([],[b,c])*g([a,b],[],d)*g([b,c],[],e))$
                             a b  b c
(%t3)                       g    g    g      g
                                       a b,d  b c,e
(%i4) ishow(canform(%))$

errexp1 has improper indices
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i5) ishow(simpmetderiv(%))$
                             a b  b c
(%t5)                       g    g    g      g
                                       a b,d  b c,e
(%i6) flipflag:not flipflag;
(%o6)                                true
(%i7) ishow(simpmetderiv(%th(2)))$
                               a b  b c
(%t7)                         g    g    g    g
                               ,d   ,e   a b  b c
(%i8) flipflag:not flipflag;
(%o8)                                false
(%i9) ishow(simpmetderiv(%th(2),stop))$
                               a b  b c
(%t9)                       - g    g    g      g
                                    ,e   a b,d  b c
(%i10) ishow(contract(%))$
                                    b c
(%t10)                           - g    g
                                    ,e   c b,d

Funktion: flush1deriv (expr, tensor)

Setzt alle tensoriellen Größen, die genau einen Ableitungsindex haben, auf den Wert Null.

Optionsvariable: vect_coords

Standardwert: false

Tensoren können durch Angabe von ganzen Zahlen nach den einzelnen Komponenten abgeleitet werden. In diesem Fall bezeichnen die ganzen Zahlen der Reihe nach die Indizes, die in der Optionsvariablen vect_coords abgelegt sind.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.4 Tensoren in gekrümmten Räumen

Funktion: imetric (g)
Systemvariable: imetric

Spezifiziert die Metrik, indem der Variablen imetric der Wert g zugewiesen wird. Die Eigenschaften für die Verjüngung von Tensoren werden mit den Kommandos defcon(g) und defcon(g, g, kdelta) initialisiert.

Funktion: idim (n)

Die Funktion idim setzt die Dimension der Metrik zu n. Die Variable dim auf den Wert n gesetzt und die antisymmetrischen Eigenschaften des Levi-Civita-Symbols für die Dimension n werden initialisiert.

Funktion: ichr1 ([i, j, k])

Gibt das Christoffel-Symbol der ersten Art zurück, das definiert ist als

       (g      + g      - g     )/2 .
         ik,j     jk,i     ij,k

Um das Christoffel-Symbol für eine spezielle Metrik auszuwerten, muss der Optionsvariablen imetric ein Wert zugewiesen werden. Siehe dazu das Beispiel zu ichr2.

Funktion: ichr2 ([i, j], [k])

Gibt das Christoffel-Symbol der zweiten Art zurück, das definiert ist als

                       ks
   ichr2([i,j],[k]) = g    (g      + g      - g     )/2
                             is,j     js,i     ij,s

Funktion: icurvature ([i, j, k], [h])

Gibt den Riemannschen Krümmungstensor in einer Darstellung mit Christoffel-Symbolen zurück:

            h             h            h         %1         h
  icurvature     = - ichr2      - ichr2     ichr2    + ichr2
            i j k         i k,j        %1 j      i k        i j,k
                            h          %1
                     + ichr2      ichr2
                            %1 k       i j

Funktion: covdiff (expr, v_1, v_2, …)

Gibt die kovariante Ableitung des Ausdruck expr nach den Variablen v_i in einer Darstellung mit Christoffel-Symbolen der zweiten Art ichr2 zurück. Um den erhaltenen Ausdruck auszuwerten, kann das Kommando ev(expr, ichr2).

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) entertensor()$
Enter tensor name: a;
Enter a list of the covariant indices: [i,j];
Enter a list of the contravariant indices: [k];
Enter a list of the derivative indices: [];
                                      k
(%t2)                                a
                                      i j
(%i3) ishow(covdiff(%,s))$
             k         %1     k         %1     k
(%t3)     - a     ichr2    - a     ichr2    + a
             i %1      j s    %1 j      i s    i j,s

             k     %1
      + ichr2     a
             %1 s  i j
(%i4) imetric:g;
(%o4)                                  g
(%i5) ishow(ev(%th(2),ichr2))$
         %1 %4  k
        g      a     (g       - g       + g      )
                i %1   s %4,j    j s,%4    j %4,s
(%t5) - ------------------------------------------
                            2
    %1 %3  k
   g      a     (g       - g       + g      )
           %1 j   s %3,i    i s,%3    i %3,s
 - ------------------------------------------
                       2
    k %2  %1
   g     a    (g        - g        + g       )
          i j   s %2,%1    %1 s,%2    %1 %2,s     k
 + ------------------------------------------- + a
                        2                         i j,s
(%i6)

Funktion: lorentz_gauge (expr)

Wendet die Lorenz-Eichung an, indem alle indizierten Größen in expr zu Null gesetzt werden, die einen zu einem kontravarianten Index identischen Ableitungsindex haben.

Funktion: igeodesic_coords (expr, name)

Bewirkt, dass nicht abgeleitete Christoffel-Symbole und erste Ableitungen des Metriktensors im Ausdruck expr verschwinden. Das Argument name bezeichnet die Metrik name, wenn im Ausdruck expr vorhanden und die Christoffel-Symbole werden mit ichr1 und ichr2 bezeichnet.

Beispiele:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) ishow(icurvature([r,s,t],[u]))$
             u            u         %1         u     
(%t2) - ichr2      - ichr2     ichr2    + ichr2      
             r t,s        %1 s      r t        r s,t 

                                              u         %1
                                       + ichr2     ichr2
                                              %1 t      r s
(%i3) ishow(igeodesic_coords(%,ichr2))$
                                 u            u
(%t3)                       ichr2      - ichr2
                                 r s,t        r t,s
(%i4) ishow(igeodesic_coords(icurvature([r,s,t],[u]),ichr2)+
            igeodesic_coords(icurvature([s,t,r],[u]),ichr2)+
            igeodesic_coords(icurvature([t,r,s],[u]),ichr2))$
             u            u            u            u
(%t4) - ichr2      + ichr2      + ichr2      - ichr2
             t s,r        t r,s        s t,r        s r,t

                                             u            u
                                      - ichr2      + ichr2
                                             r t,s        r s,t
(%i5) canform(%);
(%o5)                                  0

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.5 Begleitende Vielbeine

Maxima now has the ability to perform calculations using moving frames. These can be orthonormal frames (tetrads, vielbeins) or an arbitrary frame.

To use frames, you must first set iframe_flag to true. This causes the Christoffel-symbols, ichr1 and ichr2, to be replaced by the more general frame connection coefficients icc1 and icc2 in calculations. Speficially, the behavior of covdiff and icurvature is changed.

The frame is defined by two tensors: the inverse frame field (ifri, the dual basis tetrad), and the frame metric ifg. The frame metric is the identity matrix for orthonormal frames, or the Lorentz metric for orthonormal frames in Minkowski spacetime. The inverse frame field defines the frame base (unit vectors). Contraction properties are defined for the frame field and the frame metric.

When iframe_flag is true, many itensor expressions use the frame metric ifg instead of the metric defined by imetric for raising and lowerind indices.

IMPORTANT: Setting the variable iframe_flag to true does NOT undefine the contraction properties of a metric defined by a call to defcon or imetric. If a frame field is used, it is best to define the metric by assigning its name to the variable imetric and NOT invoke the imetric function.

Maxima uses these two tensors to define the frame coefficients (ifc1 and ifc2) which form part of the connection coefficients (icc1 and icc2), as the following example demonstrates:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) iframe_flag:true;
(%o2)                                true
(%i3) ishow(covdiff(v([],[i]),j))$
                               i        i     %1
(%t3)                         v   + icc2     v
                               ,j       %1 j
(%i4) ishow(ev(%,icc2))$
                               %1     i       i
(%t4)                         v   ifc2     + v
                                      %1 j    ,j
(%i5) ishow(ev(%,ifc2))$
                          %1    i %2                i
(%t5)                    v   ifg     ifc1        + v
                                         %1 j %2    ,j
(%i6) ishow(ev(%,ifc1))$
            %1    i %2
           v   ifg     (ifb        - ifb        + ifb       )
                           j %2 %1      %2 %1 j      %1 j %2     i
(%t6)      -------------------------------------------------- + v
                                   2                             ,j
(%i7) ishow(ifb([a,b,c]))$
                                                   %3    %4
(%t7)               (ifri        - ifri       ) ifr   ifr
                         a %3,%4       a %4,%3     b     c

An alternate method is used to compute the frame bracket (ifb) if the iframe_bracket_form flag is set to false:

(%i8) block([iframe_bracket_form:false],ishow(ifb([a,b,c])))$
                                %6    %5        %5      %6
(%t8)              ifri     (ifr   ifr     - ifr     ifr  )
                       a %5     b     c,%6      b,%6    c

Optionsvariable: iframe_flag

Standardwert: false

To use frames, you must first set iframe_flag to true. This causes the Christoffel-symbols, ichr1 and ichr2, to be replaced by the more general frame connection coefficients icc1 and icc2 in calculations. Speficially, the behavior of covdiff and icurvature is changed.

The frame is defined by two tensors: the inverse frame field (ifri, the dual basis tetrad), and the frame metric ifg. The frame metric is the identity matrix for orthonormal frames, or the Lorentz metric for orthonormal frames in Minkowski spacetime. The inverse frame field defines the frame base (unit vectors). Contraction properties are defined for the frame field and the frame metric.

When iframe_flag is true, many itensor expressions use the frame metric ifg instead of the metric defined by imetric for raising and lowerind indices.

IMPORTANT: Setting the variable iframe_flag to true does NOT undefine the contraction properties of a metric defined by a call to defcon or imetric. If a frame field is used, it is best to define the metric by assigning its name to the variable imetric and NOT invoke the imetric function.

Function: iframes ()

Since in this version of Maxima, contraction identities for ifr and ifri are always defined, as is the frame bracket (ifb), this function does nothing.

Variable: ifb

The frame bracket. The contribution of the frame metric to the connection coefficients is expressed using the frame bracket:

          - ifb      + ifb      + ifb
               c a b      b c a      a b c
ifc1    = --------------------------------
    abc                  2

The frame bracket itself is defined in terms of the frame field and frame metric. Two alternate methods of computation are used depending on the value of frame_bracket_form. If true (the default) or if the itorsion_flag is true:

          d      e                                      f
ifb =  ifr    ifr   (ifri      - ifri      - ifri    itr   )
   abc    b      c       a d,e       a e,d       a f    d e

Otherwise:

             e      d        d      e
ifb    = (ifr    ifr    - ifr    ifr   ) ifri
   abc       b      c,e      b,e    c        a d

Variable: icc1

Connection coefficients of the first kind. In itensor, defined as

icc1    = ichr1    - ikt1    - inmc1
    abc        abc       abc        abc

In this expression, if iframe_flag is true, the Christoffel-symbol ichr1 is replaced with the frame connection coefficient ifc1. If itorsion_flag is false, ikt1 will be omitted. It is also omitted if a frame base is used, as the torsion is already calculated as part of the frame bracket. Lastly, of inonmet_flag is false, inmc1 will not be present.

Variable: icc2

Connection coefficients of the second kind. In itensor, defined as

    c         c        c         c
icc2   = ichr2   - ikt2   - inmc2
    ab        ab       ab        ab

In this expression, if iframe_flag is true, the Christoffel-symbol ichr2 is replaced with the frame connection coefficient ifc2. If itorsion_flag is false, ikt2 will be omitted. It is also omitted if a frame base is used, as the torsion is already calculated as part of the frame bracket. Lastly, of inonmet_flag is false, inmc2 will not be present.

Variable: ifc1

Frame coefficient of the first kind (also known as Ricci-rotation coefficients.) This tensor represents the contribution of the frame metric to the connection coefficient of the first kind. Defined as:

          - ifb      + ifb      + ifb
               c a b      b c a      a b c
ifc1    = --------------------------------
    abc                   2

Variable: ifc2

Frame coefficient of the first kind. This tensor represents the contribution of the frame metric to the connection coefficient of the first kind. Defined as a permutation of the frame bracket (ifb) with the appropriate indices raised and lowered as necessary:

    c       cd
ifc2   = ifg   ifc1
    ab             abd

Variable: ifr

The frame field. Contracts with the inverse frame field (ifri) to form the frame metric (ifg).

Variable: ifri

The inverse frame field. Specifies the frame base (dual basis vectors). Along with the frame metric, it forms the basis of all calculations based on frames.

Variable: ifg

The frame metric. Defaults to kdelta, but can be changed using components.

Variable: ifgi

The inverse frame metric. Contracts with the frame metric (ifg) to kdelta.

Option variable: iframe_bracket_form

Default value: true

Specifies how the frame bracket (ifb) is computed.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.6 Torsion und Nichtmetrizität

Maxima can now take into account torsion and nonmetricity. When the flag itorsion_flag is set to true, the contribution of torsion is added to the connection coefficients. Similarly, when the flag inonmet_flag is true, nonmetricity components are included.

Variable: inm

The nonmetricity vector. Conformal nonmetricity is defined through the covariant derivative of the metric tensor. Normally zero, the metric tensor's covariant derivative will evaluate to the following when inonmet_flag is set to true:

g     =- g  inm
 ij;k     ij   k

Variable: inmc1

Covariant permutation of the nonmetricity vector components. Defined as

           g   inm  - inm  g   - g   inm
            ab    c      a  bc    ac    b
inmc1    = ------------------------------
     abc                 2

(Substitute ifg in place of g if a frame metric is used.)

Variable: inmc2

Contravariant permutation of the nonmetricity vector components. Used in the connection coefficients if inonmet_flag is true. Defined as:

                      c         c         cd
          -inm  kdelta  - kdelta  inm  + g   inm  g
     c        a       b         a    b          d  ab
inmc2   = -------------------------------------------
     ab                        2

(Substitute ifg in place of g if a frame metric is used.)

Variable: ikt1

Covariant permutation of the torsion tensor (also known as contorsion). Defined as:

                  d           d       d
          -g   itr  - g    itr   - itr   g
            ad    cb    bd    ca      ab  cd
ikt1    = ----------------------------------
    abc                   2

(Substitute ifg in place of g if a frame metric is used.)

Variable: ikt2

Contravariant permutation of the torsion tensor (also known as contorsion). Defined as:

    c     cd
ikt2   = g   ikt1
    ab           abd

(Substitute ifg in place of g if a frame metric is used.)

Variable: itr

The torsion tensor. For a metric with torsion, repeated covariant differentiation on a scalar function will not commute, as demonstrated by the following example:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) imetric:g;
(%o2)                                  g
(%i3) covdiff( covdiff( f( [], []), i), j)
                      - covdiff( covdiff( f( [], []), j), i)$
(%i4) ishow(%)$
                                   %4              %2
(%t4)                    f    ichr2    - f    ichr2
                          ,%4      j i    ,%2      i j
(%i5) canform(%);
(%o5)                                  0
(%i6) itorsion_flag:true;
(%o6)                                true
(%i7) covdiff( covdiff( f( [], []), i), j)
                      - covdiff( covdiff( f( [], []), j), i)$
(%i8) ishow(%)$
                           %8             %6
(%t8)             f    icc2    - f    icc2    - f     + f
                   ,%8     j i    ,%6     i j    ,j i    ,i j
(%i9) ishow(canform(%))$
                                   %1             %1
(%t9)                     f    icc2    - f    icc2
                           ,%1     j i    ,%1     i j
(%i10) ishow(canform(ev(%,icc2)))$
                                   %1             %1
(%t10)                    f    ikt2    - f    ikt2
                           ,%1     i j    ,%1     j i
(%i11) ishow(canform(ev(%,ikt2)))$
                      %2 %1                    %2 %1
(%t11)          f    g      ikt1       - f    g      ikt1
                 ,%2            i j %1    ,%2            j i %1
(%i12) ishow(factor(canform(rename(expand(ev(%,ikt1))))))$
                           %3 %2            %1       %1
                     f    g      g      (itr    - itr   )
                      ,%3         %2 %1     j i      i j
(%t12)               ------------------------------------
                                      2
(%i13) decsym(itr,2,1,[anti(all)],[]);
(%o13)                               done
(%i14) defcon(g,g,kdelta);
(%o14)                               done
(%i15) subst(g,nounify(g),%th(3))$
(%i16) ishow(canform(contract(%)))$
                                           %1
(%t16)                           - f    itr
                                    ,%1    i j

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.7 Graßmann-Algebra

The itensor package can perform operations on totally antisymmetric covariant tensor fields. A totally antisymmetric tensor field of rank (0,L) corresponds with a differential L-form. On these objects, a multiplication operation known as the exterior product, or wedge product, is defined.

Unfortunately, not all authors agree on the definition of the wedge product. Some authors prefer a definition that corresponds with the notion of antisymmetrization: in these works, the wedge product of two vector fields, for instance, would be defined as

            a a  - a a
             i j    j i
 a  /\ a  = -----------
  i     j        2

More generally, the product of a p-form and a q-form would be defined as

                       1     k1..kp l1..lq
A       /\ B       = ------ D              A       B
 i1..ip     j1..jq   (p+q)!  i1..ip j1..jq  k1..kp  l1..lq

where D stands for the Kronecker-delta.

Other authors, however, prefer a "geometric" definition that corresponds with the notion of the volume element:

a  /\ a  = a a  - a a
 i     j    i j    j i

and, in the general case

                       1    k1..kp l1..lq
A       /\ B       = ----- D              A       B
 i1..ip     j1..jq   p! q!  i1..ip j1..jq  k1..kp  l1..lq

Since itensor is a tensor algebra package, the first of these two definitions appears to be the more natural one. Many applications, however, utilize the second definition. To resolve this dilemma, a flag has been implemented that controls the behavior of the wedge product: if igeowedge_flag is false (the default), the first, "tensorial" definition is used, otherwise the second, "geometric" definition will be applied.

Operator: ~

The wedge product operator is denoted by the tilde ~. This is a binary operator. Its arguments should be expressions involving scalars, covariant tensors of rank one, or covariant tensors of rank l that have been declared antisymmetric in all covariant indices.

The behavior of the wedge product operator is controlled by the igeowedge_flag flag, as in the following example:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) ishow(a([i])~b([j]))$
                                 a  b  - b  a
                                  i  j    i  j
(%t2)                            -------------
                                       2
(%i3) decsym(a,2,0,[anti(all)],[]);
(%o3)                                done
(%i4) ishow(a([i,j])~b([k]))$
                          a    b  + b  a    - a    b
                           i j  k    i  j k    i k  j
(%t4)                     ---------------------------
                                       3
(%i5) igeowedge_flag:true;
(%o5)                                true
(%i6) ishow(a([i])~b([j]))$
(%t6)                            a  b  - b  a
                                  i  j    i  j
(%i7) ishow(a([i,j])~b([k]))$
(%t7)                     a    b  + b  a    - a    b
                           i j  k    i  j k    i k  j
Operator: |

The vertical bar | denotes the "contraction with a vector" binary operation. When a totally antisymmetric covariant tensor is contracted with a contravariant vector, the result is the same regardless which index was used for the contraction. Thus, it is possible to define the contraction operation in an index-free manner.

In the itensor package, contraction with a vector is always carried out with respect to the first index in the literal sorting order. This ensures better simplification of expressions involving the | operator. For instance:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) decsym(a,2,0,[anti(all)],[]);
(%o2)                                done
(%i3) ishow(a([i,j],[])|v)$
                                    %1
(%t3)                              v   a
                                        %1 j
(%i4) ishow(a([j,i],[])|v)$
                                     %1
(%t4)                             - v   a
                                         %1 j

Note that it is essential that the tensors used with the | operator be declared totally antisymmetric in their covariant indices. Otherwise, the results will be incorrect.

Function: extdiff (expr, i)

Computes the exterior derivative of expr with respect to the index i. The exterior derivative is formally defined as the wedge product of the partial derivative operator and a differential form. As such, this operation is also controlled by the setting of igeowedge_flag. For instance:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) ishow(extdiff(v([i]),j))$
                                  v    - v
                                   j,i    i,j
(%t2)                             -----------
                                       2
(%i3) decsym(a,2,0,[anti(all)],[]);
(%o3)                                done
(%i4) ishow(extdiff(a([i,j]),k))$
                           a      - a      + a
                            j k,i    i k,j    i j,k
(%t4)                      ------------------------
                                      3
(%i5) igeowedge_flag:true;
(%o5)                                true
(%i6) ishow(extdiff(v([i]),j))$
(%t6)                             v    - v
                                   j,i    i,j
(%i7) ishow(extdiff(a([i,j]),k))$
(%t7)                    - (a      - a      + a     )
                             k j,i    k i,j    j i,k

Function: hodge (expr)

Compute the Hodge-dual of expr. For instance:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) imetric(g);
(%o2)                            done
(%i3) idim(4);
(%o3)                            done
(%i4) icounter:100;
(%o4)                             100
(%i5) decsym(A,3,0,[anti(all)],[])$

(%i6) ishow(A([i,j,k],[]))$
(%t6)                           A
                                 i j k
(%i7) ishow(canform(hodge(%)))$
                          %1 %2 %3 %4
               levi_civita            g        A
                                       %1 %102  %2 %3 %4
(%t7)          -----------------------------------------
                                   6
(%i8) ishow(canform(hodge(%)))$
                 %1 %2 %3 %8            %4 %5 %6 %7
(%t8) levi_civita            levi_civita            g       
                                                     %1 %106
                             g        g        g      A         /6
                              %2 %107  %3 %108  %4 %8  %5 %6 %7
(%i9) lc2kdt(%)$

(%i10) %,kdelta$

(%i11) ishow(canform(contract(expand(%))))$
(%t11)                     - A
                              %106 %107 %108

Option variable: igeowedge_flag

Default value: false

Controls the behavior of the wedge product and exterior derivative. When set to false (the default), the notion of differential forms will correspond with that of a totally antisymmetric covariant tensor field. When set to true, differential forms will agree with the notion of the volume element.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.8 Exportiere als TeX

The itensor package provides limited support for exporting tensor expressions to TeX. Since itensor expressions appear as function calls, the regular Maxima tex command will not produce the expected output. You can try instead the tentex command, which attempts to translate tensor expressions into appropriately indexed TeX objects.

Function: tentex (expr)

To use the tentex function, you must first load tentex, as in the following example:

(%i1) load(itensor)$
(%i2) load(tentex)$
(%i3) idummyx:m;
(%o3)                                  m
(%i4) ishow(icurvature([j,k,l],[i]))$
            m1       i           m1       i           i
(%t4)  ichr2    ichr2     - ichr2    ichr2     - ichr2
            j k      m1 l        j l      m1 k        j l,k

                                                      i
                                               + ichr2
                                                      j k,l
(%i5) tentex(%)$
$$\Gamma_{j\,k}^{m_1}\,\Gamma_{l\,m_1}^{i}-\Gamma_{j\,l}^{m_1}\,
 \Gamma_{k\,m_1}^{i}-\Gamma_{j\,l,k}^{i}+\Gamma_{j\,k,l}^{i}$$

Note the use of the idummyx assignment, to avoid the appearance of the percent sign in the TeX expression, which may lead to compile errors.

NB: This version of the tentex function is somewhat experimental.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.9 Schnittstelle zum Paket CTENSOR

Das Paket itensor ermöglicht die Generierung von Maxima-Code, der im Kontext des Paketes ctensor ausgeführt werden kann. Die Funktion ic_convert erzeugt den Maxima-Code.

Funktion: ic_convert (eqn)

Konvertiert eine itensor-Gleichung eqn in einen ctensor-Ausdruck. Implizite Summen über Dummy-Indizes werden explizit ausgeführt und indizierte Größen werden in Arrays umgewandelt. Die Indizes der Arrays sind in der Reihenfolge der kovarianten und dann der kontravarianten Indizes der indizierte Größe. Die Ableitung einer indizierten Größe wird durch die Substantivform der Ableitung diff nach der Variablen ct_coords ersetzt, die den Index der Ableitung erhält. Die Christoffel-Symbole ichr1 und ichr2 werden zu den Funktionen lcs und mcs transformiert. Hat metricconvert den Wert true, dann wird der Metriktensor mit zwei kovarianten Indizes durch lg und mit zwei kontravarianten Indizes durch ug ersetzt. Weiterhin werden do-Schleifen für die Summation über die freien Indizes eingeführt.

Beispiele:

(%i1) load(itensor);
(%o1)      /share/tensor/itensor.lisp
(%i2) eqn:ishow(t([i,j],[k])=f([],[])*g([l,m],[])*a([],[m],j)
      *b([i],[l,k]))$
                             k        m   l k
(%t2)                       t    = f a   b    g
                             i j      ,j  i    l m
(%i3) ic_convert(eqn);
(%o3) for i thru dim do (for j thru dim do (
       for k thru dim do
        t        : f sum(sum(diff(a , ct_coords ) b
         i, j, k                   m           j   i, l, k

 g    , l, 1, dim), m, 1, dim)))
  l, m
(%i4) imetric(g);
(%o4)                                done
(%i5) metricconvert:true;
(%o5)                                true
(%i6) ic_convert(eqn);
(%o6) for i thru dim do (for j thru dim do (
       for k thru dim do
        t        : f sum(sum(diff(a , ct_coords ) b
         i, j, k                   m           j   i, l, k

 lg    , l, 1, dim), m, 1, dim)))
   l, m

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.2.2.10 Reservierte Bezeichner

Die folgenden Maxima Bezeichner werden im Paket itensor intern genutzt und sollten vom Nutzer nicht umdefiniert werden.

  Keyword    Comments
  ------------------------------------------
  indices2() Internal version of indices()
  conti      Lists contravariant indices
  covi       Lists covariant indices of a indexed object
  deri       Lists derivative indices of an indexed object
  name       Returns the name of an indexed object
  concan
  irpmon
  lc0
  _lc2kdt0
  _lcprod
  _extlc

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3 Paket CTENSOR


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.1 Einführung in CTENSOR

ctensor ist ein Paket, um mit den Komponenten eines Tensors zu rechnen. Das Paket wird mit dem Kommando load(ctensor) geladen. Zu Beginn muss das Paket mit dem Kommando csetup initialisiert werden. Als erstes wird die Anzahl der Dimensionen angegeben. Werden 2, 3 oder 4 Dimensionen angegeben, dann erhalten die Koordinaten standardmäßig die Bezeichnungen [x,y], [x,y,z] oder [x,y,z,t]. Diese Bezeichnungen können geändert werden, indem der Optionsvariablen ct_coords eine neue Liste mit den gewünschten Bezeichnungen zugewiesen wird.

Danach wird eine Metrik eingegeben oder aus einer Datei geladen. Die Metrik wird in der Matrix lg gespeichert. Maxima berechnet die inverse der Metrik und speichert diese in der Matrix ug ab. Maxima bietet die Option an, alle Rechnungen in einer Reihenentwicklung auszuführen.

Die folgende Sitzung zeigt ein Beispiel für die Initialisierung einer sphärischen, symmetrischen Metrik, wie sie zum Beispiel im Falle der Einsteinschen Vakuumgleichen verwendet wird.

Beispiel:

(%i1) load(ctensor);
(%o1)      /share/tensor/ctensor.mac
(%i2) csetup();
Enter the dimension of the coordinate system:
4;
Do you wish to change the coordinate names?
n;
Do you want to
1. Enter a new metric?

2. Enter a metric from a file?

3. Approximate a metric with a Taylor series?
1;

Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric  4. General
Answer 1, 2, 3 or 4
1;
Row 1 Column 1:
a;
Row 2 Column 2:
x^2;
Row 3 Column 3:
x^2*sin(y)^2;
Row 4 Column 4:
-d;

Matrix entered.
Enter functional dependencies with the DEPENDS function or 'N' if none
depends([a,d],x);
Do you wish to see the metric?
y;
                          [ a  0       0        0  ]
                          [                        ]
                          [     2                  ]
                          [ 0  x       0        0  ]
                          [                        ]
                          [         2    2         ]
                          [ 0  0   x  sin (y)   0  ]
                          [                        ]
                          [ 0  0       0       - d ]
(%o2)                                done
(%i3) christof(mcs);
                                            a
                                             x
(%t3)                          mcs        = ---
                                  1, 1, 1   2 a

                                             1
(%t4)                           mcs        = -
                                   1, 2, 2   x

                                             1
(%t5)                           mcs        = -
                                   1, 3, 3   x

                                            d
                                             x
(%t6)                          mcs        = ---
                                  1, 4, 4   2 d

                                              x
(%t7)                          mcs        = - -
                                  2, 2, 1     a

                                           cos(y)
(%t8)                         mcs        = ------
                                 2, 3, 3   sin(y)

                                               2
                                          x sin (y)
(%t9)                      mcs        = - ---------
                              3, 3, 1         a

(%t10)                   mcs        = - cos(y) sin(y)
                            3, 3, 2

                                            d
                                             x
(%t11)                         mcs        = ---
                                  4, 4, 1   2 a
(%o11)                               done

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2 Funktionen und Variablen für CTENSOR


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.1 Initialisierung

Funktion: csetup ()

Mit der Funktion csetup wird das Paket ctensor initialisiert. Vom Nutzer werden die Angaben zu einer Metrik abgefragt. Für ein Beispiel siehe Einführung in CTENSOR.

Funktion: cmetric (dis)
Funktion: cmetric ()

Die Funktion cmetric berechnet die inverse der Metrik und führt weitere Initialisierungen für die Rechnung mit Tensoren aus.

Hat die Optionsvariable cframe_flag den Wert false, wird die inverse Metrik mit der vom Nutzer angegebenen Metrik berechnet, die in der Matrix lg enthalten ist, und in der Matrix ug abgespeichert. Die Determinante der Metrik wird in der Variablen gdet abgelegt. Ist die Metrik diagonal wird die Variable diagmetric entsprechend gesetzt. Hat das optionale Argument dis einen von false verschiedenen Wert wird die inverse Metrik ausgegeben.

Hat die Optionsvariable cframe_flag den Wert true, erwartet cmetric, dass die Matrizen lfg für die Metrik des bewegten Bezugssystems und fri für die inverse dieser Metrik definiert sind. Mit diesen Matrizen berechnet cmetric dann die Werte der Matrizen fr und die inverse ufg.

Function: ct_coordsys (coordinate_system, extra_arg)
Function: ct_coordsys (coordinate_system)

Sets up a predefined coordinate system and metric. The argument coordinate_system can be one of the following symbols:

 SYMBOL             Dim Coordinates     Description/comments
 ------------------------------------------------------------------
 cartesian2d           2  [x,y]             Cartesian 2D coordinate
                                            system
 polar                 2  [r,phi]           Polar coordinate system
 elliptic              2  [u,v]             Elliptic coord. system
 confocalelliptic      2  [u,v]             Confocal elliptic
                                            coordinates
 bipolar               2  [u,v]             Bipolar coord. system
 parabolic             2  [u,v]             Parabolic coord. system
 cartesian3d           3  [x,y,z]           Cartesian 3D coordinate
                                            system
 polarcylindrical      3  [r,theta,z]       Polar 2D with
                                            cylindrical z
 ellipticcylindrical   3  [u,v,z]           Elliptic 2D with
                                            cylindrical z
 confocalellipsoidal   3  [u,v,w]           Confocal ellipsoidal
 bipolarcylindrical    3  [u,v,z]           Bipolar 2D with
                                            cylindrical z
 paraboliccylindrical  3  [u,v,z]           Parabolic 2D with
                                            cylindrical z
 paraboloidal          3  [u,v,phi]         Paraboloidal coords.
 conical               3  [u,v,w]           Conical coordinates
 toroidal              3  [u,v,phi]         Toroidal coordinates
 spherical             3  [r,theta,phi]     Spherical coord. system
 oblatespheroidal      3  [u,v,phi]         Oblate spheroidal
                                            coordinates
 oblatespheroidalsqrt  3  [u,v,phi]
 prolatespheroidal     3  [u,v,phi]         Prolate spheroidal
                                            coordinates
 prolatespheroidalsqrt 3  [u,v,phi]
 ellipsoidal           3  [r,theta,phi]     Ellipsoidal coordinates
 cartesian4d           4  [x,y,z,t]         Cartesian 4D coordinate
                                            system
 spherical4d           4  [r,theta,eta,phi] Spherical 4D coordinate
                                            system
 exteriorschwarzschild 4  [t,r,theta,phi]   Schwarzschild metric
 interiorschwarzschild 4  [t,z,u,v]         Interior Schwarzschild
                                            metric
 kerr_newman           4  [t,r,theta,phi]   Charged axially
                                            symmetric metric

coordinate_system can also be a list of transformation functions, followed by a list containing the coordinate variables. For instance, you can specify a spherical metric as follows:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
                   r*sin(theta),[r,theta,phi]]);
(%o2)                                done
(%i3) lg:trigsimp(lg);
                           [ 1  0         0        ]
                           [                       ]
                           [     2                 ]
(%o3)                      [ 0  r         0        ]
                           [                       ]
                           [         2    2        ]
                           [ 0  0   r  cos (theta) ]
(%i4) ct_coords;
(%o4)                           [r, theta, phi]
(%i5) dim;
(%o5)                                  3

Transformation functions can also be used when cframe_flag is true:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) cframe_flag:true;
(%o2)                                true
(%i3) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
      r*sin(theta),[r,theta,phi]]);
(%o3)                                done
(%i4) fri;
(%o4)
 [cos(phi)cos(theta) -cos(phi) r sin(theta) -sin(phi) r cos(theta)]
 [                                                                ]
 [sin(phi)cos(theta) -sin(phi) r sin(theta)  cos(phi) r cos(theta)]
 [                                                                ]
 [    sin(theta)           r cos(theta)                0          ]

(%i5) cmetric();
(%o5)                                false
(%i6) lg:trigsimp(lg);
                           [ 1  0         0        ]
                           [                       ]
                           [     2                 ]
(%o6)                      [ 0  r         0        ]
                           [                       ]
                           [         2    2        ]
                           [ 0  0   r  cos (theta) ]

The optional argument extra_arg can be any one of the following:

cylindrical tells ct_coordsys to attach an additional cylindrical coordinate.

minkowski tells ct_coordsys to attach an additional coordinate with negative metric signature.

all tells ct_coordsys to call cmetric and christof(false) after setting up the metric.

If the global variable verbose is set to true, ct_coordsys displays the values of dim, ct_coords, and either lg or lfg and fri, depending on the value of cframe_flag.

Function: init_ctensor ()

Initializes the ctensor package.

The init_ctensor function reinitializes the ctensor package. It removes all arrays and matrices used by ctensor, resets all flags, resets dim to 4, and resets the frame metric to the Lorentz-frame.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.2 The tensors of curved space

The main purpose of the ctensor package is to compute the tensors of curved space(time), most notably the tensors used in general relativity.

When a metric base is used, ctensor can compute the following tensors:

 lg  -- ug
   \      \
    lcs -- mcs -- ric -- uric
              \      \       \
               \      tracer - ein -- lein
                \
                 riem -- lriem -- weyl
                     \
                      uriem

ctensor can also work using moving frames. When cframe_flag is set to true, the following tensors can be calculated:

 lfg -- ufg
     \
 fri -- fr -- lcs -- mcs -- lriem -- ric -- uric
      \                       |  \      \       \
       lg -- ug               |   weyl   tracer - ein -- lein
                              |\
                              | riem
                              |
                              \uriem

Function: christof (dis)

A function in the ctensor (component tensor) package. It computes the Christoffel symbols of both kinds. The argument dis determines which results are to be immediately displayed. The Christoffel symbols of the first and second kinds are stored in the arrays lcs[i,j,k] and mcs[i,j,k] respectively and defined to be symmetric in the first two indices. If the argument to christof is lcs or mcs then the unique non-zero values of lcs[i,j,k] or mcs[i,j,k], respectively, will be displayed. If the argument is all then the unique non-zero values of lcs[i,j,k] and mcs[i,j,k] will be displayed. If the argument is false then the display of the elements will not occur. The array elements mcs[i,j,k] are defined in such a manner that the final index is contravariant.

Function: ricci (dis)

A function in the ctensor (component tensor) package. ricci computes the covariant (symmetric) components ric[i,j] of the Ricci tensor. If the argument dis is true, then the non-zero components are displayed.

Function: uricci (dis)

This function first computes the covariant components ric[i,j] of the Ricci tensor. Then the mixed Ricci tensor is computed using the contravariant metric tensor. If the value of the argument dis is true, then these mixed components, uric[i,j] (the index i is covariant and the index j is contravariant), will be displayed directly. Otherwise, ricci(false) will simply compute the entries of the array uric[i,j] without displaying the results.

Function: scurvature ()

Returns the scalar curvature (obtained by contracting the Ricci tensor) of the Riemannian manifold with the given metric.

Function: einstein (dis)

A function in the ctensor (component tensor) package. einstein computes the mixed Einstein tensor after the Christoffel symbols and Ricci tensor have been obtained (with the functions christof and ricci). If the argument dis is true, then the non-zero values of the mixed Einstein tensor ein[i,j] will be displayed where j is the contravariant index. The variable rateinstein will cause the rational simplification on these components. If ratfac is true then the components will also be factored.

Function: leinstein (dis)

Covariant Einstein-tensor. leinstein stores the values of the covariant Einstein tensor in the array lein. The covariant Einstein-tensor is computed from the mixed Einstein tensor ein by multiplying it with the metric tensor. If the argument dis is true, then the non-zero values of the covariant Einstein tensor are displayed.

Function: riemann (dis)

A function in the ctensor (component tensor) package. riemann computes the Riemann curvature tensor from the given metric and the corresponding Christoffel symbols. The following index conventions are used:

                l      _l       _l       _l   _m    _l   _m
 R[i,j,k,l] =  R    = |      - |      + |    |   - |    |
                ijk     ij,k     ik,j     mk   ij    mj   ik

This notation is consistent with the notation used by the itensor package and its icurvature function. If the optional argument dis is true, the non-zero components riem[i,j,k,l] will be displayed. As with the Einstein tensor, various switches set by the user control the simplification of the components of the Riemann tensor. If ratriemann is true, then rational simplification will be done. If ratfac is true then each of the components will also be factored.

If the variable cframe_flag is false, the Riemann tensor is computed directly from the Christoffel-symbols. If cframe_flag is true, the covariant Riemann-tensor is computed first from the frame field coefficients.

Function: lriemann (dis)

Covariant Riemann-tensor (lriem[]).

Computes the covariant Riemann-tensor as the array lriem. If the argument dis is true, unique nonzero values are displayed.

If the variable cframe_flag is true, the covariant Riemann tensor is computed directly from the frame field coefficients. Otherwise, the (3,1) Riemann tensor is computed first.

For information on index ordering, see riemann.

Function: uriemann (dis)

Computes the contravariant components of the Riemann curvature tensor as array elements uriem[i,j,k,l]. These are displayed if dis is true.

Function: rinvariant ()

Forms the Kretchmann-invariant (kinvariant) obtained by contracting the tensors

lriem[i,j,k,l]*uriem[i,j,k,l].

This object is not automatically simplified since it can be very large.

Function: weyl (dis)

Computes the Weyl conformal tensor. If the argument dis is true, the non-zero components weyl[i,j,k,l] will be displayed to the user. Otherwise, these components will simply be computed and stored. If the switch ratweyl is set to true, then the components will be rationally simplified; if ratfac is true then the results will be factored as well.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.3 Taylor series expansion

The ctensor package has the ability to truncate results by assuming that they are Taylor-series approximations. This behavior is controlled by the ctayswitch variable; when set to true, ctensor makes use internally of the function ctaylor when simplifying results.

The ctaylor function is invoked by the following ctensor functions:

    Function     Comments
    ---------------------------------
    christof()   For mcs only
    ricci()
    uricci()
    einstein()
    riemann()
    weyl()
    checkdiv()

Function: ctaylor ()

The ctaylor function truncates its argument by converting it to a Taylor-series using taylor, and then calling ratdisrep. This has the combined effect of dropping terms higher order in the expansion variable ctayvar. The order of terms that should be dropped is defined by ctaypov; the point around which the series expansion is carried out is specified in ctaypt.

As an example, consider a simple metric that is a perturbation of the Minkowski metric. Without further restrictions, even a diagonal metric produces expressions for the Einstein tensor that are far too complex:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) ratfac:true;
(%o2)                                true
(%i3) derivabbrev:true;
(%o3)                                true
(%i4) ct_coords:[t,r,theta,phi];
(%o4)                         [t, r, theta, phi]
(%i5) lg:matrix([-1,0,0,0],[0,1,0,0],[0,0,r^2,0],
                [0,0,0,r^2*sin(theta)^2]);
                        [ - 1  0  0         0        ]
                        [                            ]
                        [  0   1  0         0        ]
                        [                            ]
(%o5)                   [          2                 ]
                        [  0   0  r         0        ]
                        [                            ]
                        [              2    2        ]
                        [  0   0  0   r  sin (theta) ]
(%i6) h:matrix([h11,0,0,0],[0,h22,0,0],[0,0,h33,0],[0,0,0,h44]);
                            [ h11   0    0    0  ]
                            [                    ]
                            [  0   h22   0    0  ]
(%o6)                       [                    ]
                            [  0    0   h33   0  ]
                            [                    ]
                            [  0    0    0   h44 ]
(%i7) depends(l,r);
(%o7)                               [l(r)]
(%i8) lg:lg+l*h;
      [ h11 l - 1      0          0                 0            ]
      [                                                          ]
      [     0      h22 l + 1      0                 0            ]
      [                                                          ]
(%o8) [                        2                                 ]
      [     0          0      r  + h33 l            0            ]
      [                                                          ]
      [                                    2    2                ]
      [     0          0          0       r  sin (theta) + h44 l ]
(%i9) cmetric(false);
(%o9)                                done
(%i10) einstein(false);
(%o10)                               done
(%i11) ntermst(ein);
[[1, 1], 62]
[[1, 2], 0]
[[1, 3], 0]
[[1, 4], 0]
[[2, 1], 0]
[[2, 2], 24]
[[2, 3], 0]
[[2, 4], 0]
[[3, 1], 0]
[[3, 2], 0]
[[3, 3], 46]
[[3, 4], 0]
[[4, 1], 0]
[[4, 2], 0]
[[4, 3], 0]
[[4, 4], 46]
(%o12)                               done

However, if we recompute this example as an approximation that is linear in the variable l, we get much simpler expressions:

(%i14) ctayswitch:true;
(%o14)                               true
(%i15) ctayvar:l;
(%o15)                                 l
(%i16) ctaypov:1;
(%o16)                                 1
(%i17) ctaypt:0;
(%o17)                                 0
(%i18) christof(false);
(%o18)                               done
(%i19) ricci(false);
(%o19)                               done
(%i20) einstein(false);
(%o20)                               done
(%i21) ntermst(ein);
[[1, 1], 6]
[[1, 2], 0]
[[1, 3], 0]
[[1, 4], 0]
[[2, 1], 0]
[[2, 2], 13]
[[2, 3], 2]
[[2, 4], 0]
[[3, 1], 0]
[[3, 2], 2]
[[3, 3], 9]
[[3, 4], 0]
[[4, 1], 0]
[[4, 2], 0]
[[4, 3], 0]
[[4, 4], 9]
(%o21)                               done
(%i22) ratsimp(ein[1,1]);
                         2      2  4               2     2
(%o22) - (((h11 h22 - h11 ) (l )  r  - 2 h33 l    r ) sin (theta)
                              r               r r

                            2               2      4    2
              - 2 h44 l    r  - h33 h44 (l ) )/(4 r  sin (theta))
                       r r                r

This capability can be useful, for instance, when working in the weak field limit far from a gravitational source.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.4 Frame fields

Optionsvariable: cframe_flag

Standardwert: false

When the variable cframe_flag is set to true, the ctensor package performs its calculations using a moving frame.

Function: frame_bracket (fr, fri, diagframe)

The frame bracket (fb[]).

Computes the frame bracket according to the following definition:

   c          c         c        d     e
ifb   = ( ifri    - ifri    ) ifr   ifr
   ab         d,e       e,d      a     b

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.5 Algebraic classification

A new feature (as of November, 2004) of ctensor is its ability to compute the Petrov classification of a 4-dimensional spacetime metric. For a demonstration of this capability, see the file share/tensor/petrov.dem.

Function: nptetrad ()

Computes a Newman-Penrose null tetrad (np) and its raised-index counterpart (npi). See petrov for an example.

The null tetrad is constructed on the assumption that a four-diemensional orthonormal frame metric with metric signature (-,+,+,+) is being used. The components of the null tetrad are related to the inverse frame matrix as follows:

np  = (fri  + fri ) / sqrt(2)
  1       1      2

np  = (fri  - fri ) / sqrt(2)
  2       1      2

np  = (fri  + %i fri ) / sqrt(2)
  3       3         4

np  = (fri  - %i fri ) / sqrt(2)
  4       3         4

Function: psi (dis)

Computes the five Newman-Penrose coefficients psi[0]...psi[4]. If psi is set to true, the coefficients are displayed. See petrov for an example.

These coefficients are computed from the Weyl-tensor in a coordinate base. If a frame base is used, the Weyl-tensor is first converted to a coordinate base, which can be a computationally expensive procedure. For this reason, in some cases it may be more advantageous to use a coordinate base in the first place before the Weyl tensor is computed. Note however, that constructing a Newman-Penrose null tetrad requires a frame base. Therefore, a meaningful computation sequence may begin with a frame base, which is then used to compute lg (computed automatically by cmetric and then ug. At this point, you can switch back to a coordinate base by setting cframe_flag to false before beginning to compute the Christoffel symbols. Changing to a frame base at a later stage could yield inconsistent results, as you may end up with a mixed bag of tensors, some computed in a frame base, some in a coordinate base, with no means to distinguish between the two.

Function: petrov ()

Computes the Petrov classification of the metric characterized by psi[0]psi[4].

For example, the following demonstrates how to obtain the Petrov-classification of the Kerr metric:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) (cframe_flag:true,gcd:spmod,ctrgsimp:true,ratfac:true);
(%o2)                                true
(%i3) ct_coordsys(exteriorschwarzschild,all);
(%o3)                                done
(%i4) ug:invert(lg)$
(%i5) weyl(false);
(%o5)                                done
(%i6) nptetrad(true);
(%t6) np =

[ sqrt(r - 2 m)           sqrt(r)                                 ]
[---------------   ---------------------    0            0        ]
[sqrt(2) sqrt(r)   sqrt(2) sqrt(r - 2 m)                          ]
[                                                                 ]
[ sqrt(r - 2 m)            sqrt(r)                                ]
[---------------  - ---------------------   0            0        ]
[sqrt(2) sqrt(r)    sqrt(2) sqrt(r - 2 m)                         ]
[                                                                 ]
[                                          r      %i r sin(theta) ]
[       0                    0          -------   --------------- ]
[                                       sqrt(2)       sqrt(2)     ]
[                                                                 ]
[                                          r       %i r sin(theta)]
[       0                    0          -------  - ---------------]
[                                       sqrt(2)        sqrt(2)    ]

                             sqrt(r)         sqrt(r - 2 m)
(%t7) npi = matrix([- ---------------------,---------------, 0, 0],
                      sqrt(2) sqrt(r - 2 m) sqrt(2) sqrt(r)

          sqrt(r)            sqrt(r - 2 m)
[- ---------------------, - ---------------, 0, 0],
   sqrt(2) sqrt(r - 2 m)    sqrt(2) sqrt(r)

           1               %i
[0, 0, ---------, --------------------],
       sqrt(2) r  sqrt(2) r sin(theta)

           1                 %i
[0, 0, ---------, - --------------------])
       sqrt(2) r    sqrt(2) r sin(theta)

(%o7)                                done
(%i7) psi(true);
(%t8)                              psi  = 0
                                      0

(%t9)                              psi  = 0
                                      1

                                          m
(%t10)                             psi  = --
                                      2    3
                                          r

(%t11)                             psi  = 0
                                      3

(%t12)                             psi  = 0
                                      4
(%o12)                               done
(%i12) petrov();
(%o12)                                 D

The Petrov classification function is based on the algorithm published in "Classifying geometries in general relativity: III Classification in practice" by Pollney, Skea, and d'Inverno, Class. Quant. Grav. 17 2885-2902 (2000). Except for some simple test cases, the implementation is untested as of December 19, 2004, and is likely to contain errors.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.6 Torsion and nonmetricity

ctensor has the ability to compute and include torsion and nonmetricity coefficients in the connection coefficients.

The torsion coefficients are calculated from a user-supplied tensor tr, which should be a rank (2,1) tensor. From this, the torsion coefficients kt are computed according to the following formulae:

              m          m      m
       - g  tr   - g   tr   - tr   g
          im  kj    jm   ki     ij  km
kt   = -------------------------------
  ijk                 2


  k     km
kt   = g   kt
  ij         ijm

Note that only the mixed-index tensor is calculated and stored in the array kt.

The nonmetricity coefficients are calculated from the user-supplied nonmetricity vector nm. From this, the nonmetricity coefficients nmc are computed as follows:

             k    k        km
       -nm  D  - D  nm  + g   nm  g
   k      i  j    i   j         m  ij
nmc  = ------------------------------
   ij                2

where D stands for the Kronecker-delta.

When ctorsion_flag is set to true, the values of kt are substracted from the mixed-indexed connection coefficients computed by christof and stored in mcs. Similarly, if cnonmet_flag is set to true, the values of nmc are substracted from the mixed-indexed connection coefficients.

If necessary, christof calls the functions contortion and nonmetricity in order to compute kt and nm.

Function: contortion (tr)

Computes the (2,1) contortion coefficients from the torsion tensor tr.

Function: nonmetricity (nm)

Computes the (2,1) nonmetricity coefficients from the nonmetricity vector nm.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.7 Miscellaneous features

Function: ctransform (M)

A function in the ctensor (component tensor) package which will perform a coordinate transformation upon an arbitrary square symmetric matrix M. The user must input the functions which define the transformation. (Formerly called transform.)

Function: findde (A, n)

returns a list of the unique differential equations (expressions) corresponding to the elements of the n dimensional square array A. Presently, n may be 2 or 3. deindex is a global list containing the indices of A corresponding to these unique differential equations. For the Einstein tensor (ein), which is a two dimensional array, if computed for the metric in the example below, findde gives the following independent differential equations:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) derivabbrev:true;
(%o2)                                true
(%i3) dim:4;
(%o3)                                  4
(%i4) lg:matrix([a, 0, 0, 0], [ 0, x^2, 0, 0],
                              [0, 0, x^2*sin(y)^2, 0], [0,0,0,-d]);
                          [ a  0       0        0  ]
                          [                        ]
                          [     2                  ]
                          [ 0  x       0        0  ]
(%o4)                     [                        ]
                          [         2    2         ]
                          [ 0  0   x  sin (y)   0  ]
                          [                        ]
                          [ 0  0       0       - d ]
(%i5) depends([a,d],x);
(%o5)                            [a(x), d(x)]
(%i6) ct_coords:[x,y,z,t];
(%o6)                            [x, y, z, t]
(%i7) cmetric();
(%o7)                                done
(%i8) einstein(false);
(%o8)                                done
(%i9) findde(ein,2);
                                            2
(%o9) [d  x - a d + d, 2 a d d    x - a (d )  x - a  d d  x
        x                     x x         x        x    x

                                              2          2
                          + 2 a d d   - 2 a  d , a  x + a  - a]
                                   x       x      x
(%i10) deindex;
(%o10)                     [[1, 1], [2, 2], [4, 4]]

Function: cograd ()

Computes the covariant gradient of a scalar function allowing the user to choose the corresponding vector name as the example under contragrad illustrates.

Function: contragrad ()

Computes the contravariant gradient of a scalar function allowing the user to choose the corresponding vector name as the example below for the Schwarzschild metric illustrates:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) derivabbrev:true;
(%o2)                                true
(%i3) ct_coordsys(exteriorschwarzschild,all);
(%o3)                                done
(%i4) depends(f,r);
(%o4)                               [f(r)]
(%i5) cograd(f,g1);
(%o5)                                done
(%i6) listarray(g1);
(%o6)                            [0, f , 0, 0]
                                      r
(%i7) contragrad(f,g2);
(%o7)                                done
(%i8) listarray(g2);
                               f  r - 2 f  m
                                r        r
(%o8)                      [0, -------------, 0, 0]
                                     r

Function: dscalar ()

computes the tensor d'Alembertian of the scalar function once dependencies have been declared upon the function. For example:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) derivabbrev:true;
(%o2)                                true
(%i3) ct_coordsys(exteriorschwarzschild,all);
(%o3)                                done
(%i4) depends(p,r);
(%o4)                               [p(r)]
(%i5) factor(dscalar(p));
                          2
                    p    r  - 2 m p    r + 2 p  r - 2 m p
                     r r           r r        r          r
(%o5)               --------------------------------------
                                       2
                                      r

Function: checkdiv ()

computes the covariant divergence of the mixed second rank tensor (whose first index must be covariant) by printing the corresponding n components of the vector field (the divergence) where n = dim. If the argument to the function is g then the divergence of the Einstein tensor will be formed and must be zero. In addition, the divergence (vector) is given the array name div.

Function: cgeodesic (dis)

A function in the ctensor (component tensor) package. cgeodesic computes the geodesic equations of motion for a given metric. They are stored in the array geod[i]. If the argument dis is true then these equations are displayed.

Function: bdvac (f)

generates the covariant components of the vacuum field equations of the Brans- Dicke gravitational theory. The scalar field is specified by the argument f, which should be a (quoted) function name with functional dependencies, e.g., 'p(x).

The components of the second rank covariant field tensor are represented by the array bd.

Function: invariant1 ()

generates the mixed Euler- Lagrange tensor (field equations) for the invariant density of R^2. The field equations are the components of an array named inv1.

Function: invariant2 ()

*** NOT YET IMPLEMENTED ***

generates the mixed Euler- Lagrange tensor (field equations) for the invariant density of ric[i,j]*uriem[i,j]. The field equations are the components of an array named inv2.

Function: bimetric ()

*** NOT YET IMPLEMENTED ***

generates the field equations of Rosen's bimetric theory. The field equations are the components of an array named rosen.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.8 Utility functions

Function: diagmatrixp (M)

Returns true if M is a diagonal matrix or (2D) array.

Function: symmetricp (M)

Returns true if M is a symmetric matrix or (2D) array.

Function: ntermst (f)

gives the user a quick picture of the "size" of the doubly subscripted tensor (array) f. It prints two element lists where the second element corresponds to NTERMS of the components specified by the first elements. In this way, it is possible to quickly find the non-zero expressions and attempt simplification.

Function: cdisplay (ten)

displays all the elements of the tensor ten, as represented by a multidimensional array. Tensors of rank 0 and 1, as well as other types of variables, are displayed as with ldisplay. Tensors of rank 2 are displayed as 2-dimensional matrices, while tensors of higher rank are displayed as a list of 2-dimensional matrices. For instance, the Riemann-tensor of the Schwarzschild metric can be viewed as:

(%i1) load(ctensor);
(%o1)       /share/tensor/ctensor.mac
(%i2) ratfac:true;
(%o2)                                true
(%i3) ct_coordsys(exteriorschwarzschild,all);
(%o3)                                done
(%i4) riemann(false);
(%o4)                                done
(%i5) cdisplay(riem);
          [ 0               0                   0           0     ]
          [                                                       ]
          [                              2                        ]
          [      3 m (r - 2 m)   m    2 m                         ]
          [ 0  - ------------- + -- - ----      0           0     ]
          [            4          3     4                         ]
          [           r          r     r                          ]
          [                                                       ]
riem    = [                                m (r - 2 m)            ]
    1, 1  [ 0               0              -----------      0     ]
          [                                     4                 ]
          [                                    r                  ]
          [                                                       ]
          [                                           m (r - 2 m) ]
          [ 0               0                   0     ----------- ]
          [                                                4      ]
          [                                               r       ]

                                [    2 m (r - 2 m)       ]
                                [ 0  -------------  0  0 ]
                                [          4             ]
                                [         r              ]
                     riem     = [                        ]
                         1, 2   [ 0        0        0  0 ]
                                [                        ]
                                [ 0        0        0  0 ]
                                [                        ]
                                [ 0        0        0  0 ]

                                [         m (r - 2 m)    ]
                                [ 0  0  - -----------  0 ]
                                [              4         ]
                                [             r          ]
                     riem     = [                        ]
                         1, 3   [ 0  0        0        0 ]
                                [                        ]
                                [ 0  0        0        0 ]
                                [                        ]
                                [ 0  0        0        0 ]

                                [            m (r - 2 m) ]
                                [ 0  0  0  - ----------- ]
                                [                 4      ]
                                [                r       ]
                     riem     = [                        ]
                         1, 4   [ 0  0  0        0       ]
                                [                        ]
                                [ 0  0  0        0       ]
                                [                        ]
                                [ 0  0  0        0       ]

                               [       0         0  0  0 ]
                               [                         ]
                               [       2 m               ]
                               [ - ------------  0  0  0 ]
                    riem     = [    2                    ]
                        2, 1   [   r  (r - 2 m)          ]
                               [                         ]
                               [       0         0  0  0 ]
                               [                         ]
                               [       0         0  0  0 ]

             [     2 m                                         ]
             [ ------------  0        0               0        ]
             [  2                                              ]
             [ r  (r - 2 m)                                    ]
             [                                                 ]
             [      0        0        0               0        ]
             [                                                 ]
  riem     = [                         m                       ]
      2, 2   [      0        0  - ------------        0        ]
             [                     2                           ]
             [                    r  (r - 2 m)                 ]
             [                                                 ]
             [                                         m       ]
             [      0        0        0         - ------------ ]
             [                                     2           ]
             [                                    r  (r - 2 m) ]

                                [ 0  0       0        0 ]
                                [                       ]
                                [            m          ]
                                [ 0  0  ------------  0 ]
                     riem     = [        2              ]
                         2, 3   [       r  (r - 2 m)    ]
                                [                       ]
                                [ 0  0       0        0 ]
                                [                       ]
                                [ 0  0       0        0 ]

                                [ 0  0  0       0       ]
                                [                       ]
                                [               m       ]
                                [ 0  0  0  ------------ ]
                     riem     = [           2           ]
                         2, 4   [          r  (r - 2 m) ]
                                [                       ]
                                [ 0  0  0       0       ]
                                [                       ]
                                [ 0  0  0       0       ]

                                      [ 0  0  0  0 ]
                                      [            ]
                                      [ 0  0  0  0 ]
                                      [            ]
                           riem     = [ m          ]
                               3, 1   [ -  0  0  0 ]
                                      [ r          ]
                                      [            ]
                                      [ 0  0  0  0 ]

                                      [ 0  0  0  0 ]
                                      [            ]
                                      [ 0  0  0  0 ]
                                      [            ]
                           riem     = [    m       ]
                               3, 2   [ 0  -  0  0 ]
                                      [    r       ]
                                      [            ]
                                      [ 0  0  0  0 ]

                               [   m                      ]
                               [ - -   0   0       0      ]
                               [   r                      ]
                               [                          ]
                               [        m                 ]
                               [  0   - -  0       0      ]
                    riem     = [        r                 ]
                        3, 3   [                          ]
                               [  0    0   0       0      ]
                               [                          ]
                               [              2 m - r     ]
                               [  0    0   0  ------- + 1 ]
                               [                 r        ]

                                    [ 0  0  0    0   ]
                                    [                ]
                                    [ 0  0  0    0   ]
                                    [                ]
                         riem     = [            2 m ]
                             3, 4   [ 0  0  0  - --- ]
                                    [             r  ]
                                    [                ]
                                    [ 0  0  0    0   ]

                                [       0        0  0  0 ]
                                [                        ]
                                [       0        0  0  0 ]
                                [                        ]
                     riem     = [       0        0  0  0 ]
                         4, 1   [                        ]
                                [      2                 ]
                                [ m sin (theta)          ]
                                [ -------------  0  0  0 ]
                                [       r                ]

                                [ 0        0        0  0 ]
                                [                        ]
                                [ 0        0        0  0 ]
                                [                        ]
                     riem     = [ 0        0        0  0 ]
                         4, 2   [                        ]
                                [         2              ]
                                [    m sin (theta)       ]
                                [ 0  -------------  0  0 ]
                                [          r             ]

                              [ 0  0          0          0 ]
                              [                            ]
                              [ 0  0          0          0 ]
                              [                            ]
                   riem     = [ 0  0          0          0 ]
                       4, 3   [                            ]
                              [                2           ]
                              [         2 m sin (theta)    ]
                              [ 0  0  - ---------------  0 ]
                              [                r           ]

           [        2                                             ]
           [   m sin (theta)                                      ]
           [ - -------------         0                0         0 ]
           [         r                                            ]
           [                                                      ]
           [                         2                            ]
           [                    m sin (theta)                     ]
riem     = [        0         - -------------         0         0 ]
    4, 4   [                          r                           ]
           [                                                      ]
           [                                          2           ]
           [                                   2 m sin (theta)    ]
           [        0                0         ---------------  0 ]
           [                                          r           ]
           [                                                      ]
           [        0                0                0         0 ]

(%o5)                                done

Function: deleten (L, n)

Returns a new list consisting of L with the n'th element deleted.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.9 Variables used by ctensor

Option variable: dim

Default value: 4

An option in the ctensor (component tensor) package. dim is the dimension of the manifold with the default 4. The command dim: n will reset the dimension to any other value n.

Option variable: diagmetric

Default value: false

An option in the ctensor (component tensor) package. If diagmetric is true special routines compute all geometrical objects (which contain the metric tensor explicitly) by taking into consideration the diagonality of the metric. Reduced run times will, of course, result. Note: this option is set automatically by csetup if a diagonal metric is specified.

Option variable: ctrgsimp

Causes trigonometric simplifications to be used when tensors are computed. Presently, ctrgsimp affects only computations involving a moving frame.

Option variable: cframe_flag

Causes computations to be performed relative to a moving frame as opposed to a holonomic metric. The frame is defined by the inverse frame array fri and the frame metric lfg. For computations using a Cartesian frame, lfg should be the unit matrix of the appropriate dimension; for computations in a Lorentz frame, lfg should have the appropriate signature.

Option variable: ctorsion_flag

Causes the contortion tensor to be included in the computation of the connection coefficients. The contortion tensor itself is computed by contortion from the user-supplied tensor tr.

Option variable: cnonmet_flag

Causes the nonmetricity coefficients to be included in the computation of the connection coefficients. The nonmetricity coefficients are computed from the user-supplied nonmetricity vector nm by the function nonmetricity.

Option variable: ctayswitch

If set to true, causes some ctensor computations to be carried out using Taylor-series expansions. Presently, christof, ricci, uricci, einstein, and weyl take into account this setting.

Option variable: ctayvar

Variable used for Taylor-series expansion if ctayswitch is set to true.

Option variable: ctaypov

Maximum power used in Taylor-series expansion when ctayswitch is set to true.

Option variable: ctaypt

Point around which Taylor-series expansion is carried out when ctayswitch is set to true.

System variable: gdet

The determinant of the metric tensor lg. Computed by cmetric when cframe_flag is set to false.

Option variable: ratchristof

Causes rational simplification to be applied by christof.

Option variable: rateinstein

Default value: true

If true rational simplification will be performed on the non-zero components of Einstein tensors; if ratfac is true then the components will also be factored.

Option variable: ratriemann

Default value: true

One of the switches which controls simplification of Riemann tensors; if true, then rational simplification will be done; if ratfac is true then each of the components will also be factored.

Option variable: ratweyl

Default value: true

If true, this switch causes the weyl function to apply rational simplification to the values of the Weyl tensor. If ratfac is true, then the components will also be factored.

Variable: lfg

The covariant frame metric. By default, it is initialized to the 4-dimensional Lorentz frame with signature (+,+,+,-). Used when cframe_flag is true.

Variable: ufg

The inverse frame metric. Computed from lfg when cmetric is called while cframe_flag is set to true.

Variable: riem

The (3,1) Riemann tensor. Computed when the function riemann is invoked. For information about index ordering, see the description of riemann.

If cframe_flag is true, riem is computed from the covariant Riemann-tensor lriem.

Variable: lriem

The covariant Riemann tensor. Computed by lriemann.

Variable: uriem

The contravariant Riemann tensor. Computed by uriemann.

Variable: ric

The mixed Ricci-tensor. Computed by ricci.

Variable: uric

The contravariant Ricci-tensor. Computed by uricci.

Variable: lg

The metric tensor. This tensor must be specified (as a dim by dim matrix) before other computations can be performed.

Variable: ug

The inverse of the metric tensor. Computed by cmetric.

Variable: weyl

The Weyl tensor. Computed by weyl.

Variable: fb

Frame bracket coefficients, as computed by frame_bracket.

Variable: kinvariant

The Kretchmann invariant. Computed by rinvariant.

Variable: np

A Newman-Penrose null tetrad. Computed by nptetrad.

Variable: npi

The raised-index Newman-Penrose null tetrad. Computed by nptetrad. Defined as ug.np. The product np.transpose(npi) is constant:

(%i39) trigsimp(np.transpose(npi));
                              [  0   - 1  0  0 ]
                              [                ]
                              [ - 1   0   0  0 ]
(%o39)                        [                ]
                              [  0    0   0  1 ]
                              [                ]
                              [  0    0   1  0 ]

Variable: tr

User-supplied rank-3 tensor representing torsion. Used by contortion.

Variable: kt

The contortion tensor, computed from tr by contortion.

Variable: nm

User-supplied nonmetricity vector. Used by nonmetricity.

Variable: nmc

The nonmetricity coefficients, computed from nm by nonmetricity.

System variable: tensorkill

Variable indicating if the tensor package has been initialized. Set and used by csetup, reset by init_ctensor.

Option variable: ct_coords

Default value: []

An option in the ctensor (component tensor) package. ct_coords contains a list of coordinates. While normally defined when the function csetup is called, one may redefine the coordinates with the assignment ct_coords: [j1, j2, ..., jn] where the j's are the new coordinate names. See also csetup.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.10 Reserved names

The following names are used internally by the ctensor package and should not be redefined:

  Name         Description
  ---------------------------------------------------------------------
  _lg()        Evaluates to lfg if frame metric used, lg otherwise
  _ug()        Evaluates to ufg if frame metric used, ug otherwise
  cleanup()    Removes items drom the deindex list
  contract4()  Used by psi()
  filemet()    Used by csetup() when reading the metric from a file
  findde1()    Used by findde()
  findde2()    Used by findde()
  findde3()    Used by findde()
  kdelt()      Kronecker-delta (not generalized)
  newmet()     Used by csetup() for setting up a metric interactively
  setflags()   Used by init_ctensor()
  readvalue()
  resimp()
  sermet()     Used by csetup() for entering a metric as Taylor-series
  txyzsum()
  tmetric()    Frame metric, used by cmetric() when cframe_flag:true
  triemann()   Riemann-tensor in frame base, used when cframe_flag:true
  tricci()     Ricci-tensor in frame base, used when cframe_flag:true
  trrc()       Ricci rotation coefficients, used by christof()
  yesp()

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.3.2.11 Changes

In November, 2004, the ctensor package was extensively rewritten. Many functions and variables have been renamed in order to make the package compatible with the commercial version of Macsyma.

  New Name     Old Name        Description
  ---------------------------------------------------------------------
  ctaylor()    DLGTAYLOR()     Taylor-series expansion of an expression
  lgeod[]      EM              Geodesic equations
  ein[]        G[]             Mixed Einstein-tensor
  ric[]        LR[]            Mixed Ricci-tensor
  ricci()      LRICCICOM()     Compute the mixed Ricci-tensor
  ctaypov      MINP            Maximum power in Taylor-series expansion
  cgeodesic()  MOTION          Compute geodesic equations
  ct_coords    OMEGA           Metric coordinates
  ctayvar      PARAM           Taylor-series expansion variable
  lriem[]      R[]             Covariant Riemann-tensor
  uriemann()   RAISERIEMANN()  Compute the contravariant Riemann-tensor
  ratriemann   RATRIEMAN       Rational simplif. of the Riemann-tensor
  uric[]       RICCI[]         Contravariant Ricci-tensor
  uricci()     RICCICOM()      Compute the contravariant Ricci-tensor
  cmetric()    SETMETRIC()     Set up the metric
  ctaypt       TAYPT           Point for Taylor-series expansion
  ctayswitch   TAYSWITCH       Taylor-series setting switch
  csetup()     TSETUP()        Start interactive setup session
  ctransform() TTRANSFORM()    Interactive coordinate transformation
  uriem[]      UR[]            Contravariant Riemann-tensor
  weyl[]       W[]             (3,1) Weyl-tensor

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.4 Paket ATENSOR


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.4.1 Einführung in ATENSOR

Das Paket atensor erlaubt das algebraische Rechnen mit Tensoren. Mit dem Kommando load(atensor) wird das Paket geladen. Um das Paket zu initialisieren, wird die Funktion init_atensor ausgeführt.

Im wesentlichen enthält das Paket atensor Regeln für die Vereinfachung von Ausdrücken mit dem dot-Operator Operator ".". atensor kennt verschiedene Algebren. Mit der Funktion init_atensor werden die Regeln einer Algebra initialisiert.

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

    i = v     j = v     k = v  . v
         1         2         1    2

Das Paket 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.

(%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            ]

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

Die Bilinearformen sf, af und av können vom Nutzer neu definiert werden, um eine gewünschte Algebra zu definieren.

Wird das Paket atensor geladen, werden die folgenden Schalter auf die angegebenen Werte gesetzt:

dotscrules  : true
dotdistrib  : true
dotexptsimp : false

Wird das symbolische Rechnen in einer nicht-assoziativen Algebra gewünscht, kann auch noch der Schalter dotassoc auf den Wert false gesetzt werden. In diesem Fall kann jedoch die Funktion atensimp nicht immer eine gewünschte Vereinfachung erzielen.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

20.4.2 Funktionen und Variablen für ATENSOR

Funktion: init_atensor (alg_type, opt_dims)
Funktion: init_atensor (alg_type)

Initialisiert das Paket atensor mit der angegebenen Algebra alg_type. Das Argument alg_type kann einen der folgenden Werte haben:

universal

Eine allgemeine Algebra, für die keine Vertauschungsregeln definiert sind.

grassmann

Eine Graßmann-Algebra, für die die Vertauschungsregel u.v + v.u = 0 definiert ist.

clifford

Eine Clifford-Algebra, die durch die Vertauschungsregel u.v + v.u = -2*sf(u,v) definiert ist. Die Bilinearform sf ist eine symmetrische Funktion, die einen skalaren Wert als Ergebnis hat. Das Argument opt_dims kann bis zu drei positive ganze Zahlen sein, die die positiven, entarteten und negativen Dimensionen der Algebra bezeichnen. Die Dimension adim und die Matrix aform werden entsprechend der angegebenen Argumente opt_dims initialisiert. Sind keine Argumente opt_dims vorhanden, wird die Dimension adim zu Null initialisiert und keine Matrix aform definiert.

symmetric

Eine symmetrische Algebra, die durch die Vertauschungsregel u.v - v.u = 0 definiert ist.

symplectic

Eine symplektische Algebra, die durch die Vertauschungsregel u.v - v.u = 2*af(u,v) definiert ist. Die Bilinearform af ist eine antisymmetrische Funktion, die einen skalaren Wert als Ergebnis hat. Das Argument opt_dims kann bis zu zwei positive ganze Zahlen enthalten, die die nicht-degenerierten und degenerierten Dimensionen der Algebra bezeichnen. Die Dimension adim und die Matrix aform werden entsprechend der angegebenen Argumente opt_dims initialisiert. Sind keine Argumente opt_dims vorhanden, wird die Dimension adim zu Null initialisiert und keine Matrix aform definiert.

lie_envelop

Eine einhüllende Lie-Algebra, die durch die Vertauschungsregel u.v - v.u = 2*av(u,v) definiert ist, wobei die Bilinearform av eine antisymmetrische Funktion ist. Das Argument opt_dims kann eine positive ganze Zahl sein, welche die Dimension der Lie-Algebra angibt. Die Dimension adim und die Matrix aform werden entsprechend des Argumentes opt_dims initialisiert. Ist kein Argument opt_dims vorhanden, wird die Dimension adim zu Null initialisiert und keine Matrix aform definiert.

Die Funktion init_atensor kennt weiterhin einige vordefinierte Algebren:

complex

Die Algebra der komplexen Zahlen, die als eine Clifford-Algebra Cl(0,1) definiert wird. Das Kommando init_atensor(complex) ist äquivalent zum Kommando init_atensor(clifford, 0, 0, 1).

quaternion

Die Algebra der Quaternionen, die als eine Clifford-Algebra vom Typ Cl(0,2) definiert wird. Das Kommando init_atensor(quaternion) ist äquivalent zum Kommando init_atensor(clifford, 0, 0, 2).

pauli

Die Algebra der Pauli-Matrizen, die als eine Clifford-Algebra Cl(3,0) definiert wird. Das Kommando init_atensor(pauli) ist äquivalent zum Kommando init_atensor(clifford, 3).

dirac

Die Algebra der Dirac-Matrizen, die als eine Clifford-Algebra Cl(3,0,1) definiert wird. Das Kommando init_atensor(dirac) ist äquivalent zum Kommando init_atensor(clifford, 3, 0, 1).

Funktion: atensimp (expr)

Vereinfacht einen Ausdruck expr entsprechend der Regeln für die Algebra, die mit der Funktion init_atensor festgelegt ist. Die Regeln werden rekursiv auf den Ausdruck angewendet. Dabei werden auch Bilinearformen sf, af und av ausgewertet.

Beispiele:

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

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

Optionsvariable: alg_type

Standardwert: universal

Der Typ der Algebra, die bei der Vereinfachung von Ausdrücken mit der Funktion atensimp angewendet wird. Die Algebra wird von der Funktion init_atensor initialisiert. Mögliche Algebren sind universal, grassmann, clifford, symmetric, symplectic und lie_envelop. Siehe für eine ausführliche Erläuterung der Algebren die Funktion init_atensor.

Optionsvariable: adim

Standardwert: 0

Die Dimension der Algebra, die bei der Vereinfachung von Ausdrücken mit der Funktion atensimp angewendet wird. Die Dimension wird von der Funktion init_atensor initialisiert. Ein indiziertes Symbol mit dem Bezeichner asymbol ist dann ein Basisvektor, wenn der Index kleiner oder gleich der Dimension adim ist.

Beispiel:

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

(%i1) load(atensor)$

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

Optionsvariable: aform

Standardwert: ident(3)

Matrix mit den Werten der Bilinearformen sf, af und av. Der Standardwert ist die dreidimensionale Einheitsmatrix.

Beispiel:

Das Beispiel zeigt die Matrix aform für eine Lie-Algebra mit drei Dimensionen und die Ergebnisse der Bilinearform av für diese Algebra.

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

Optionsvariable: asymbol

Standardwert: v

Enthält das Symbol, das einen Basisvektor des Paketes atensor bezeichnet. Mit der Funktion abasep kann getestet werde, ob ein indiziertes Symbol einen Basisvektor der Algebra bezeichnet.

Beispiel:

In diesem Beispiel wird asymbol auf den Wert x gesetzt.

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

Funktion: sf (u, v)

Eine symmetrische Bilinearform, die bei der Vereinfachung von Ausdrücken mit der Funktion atensimp angewendet wird. Die Funktion kann vom Nutzer durch eine neue Funktion ersetzt werden. Die Standardimplementation prüft mit der Funktion abasep, ob die Argumente u und v Basisvektoren sind und setzt für diesen Fall den entsprechen Wert der Matrix aform ein.

Funktion: af (u, v)

Eine antisymmetrische Bilinearform, die bei der Vereinfachung von Ausdrücken mit der Funktion atensimp angewendet wird. Die Funktion kann vom Nutzer durch eine neue Funktion ersetzt werden. Die Standardimplementation prüft mit der Funktion abasep, ob die Argumente u und v Basisvektoren sind und setzt für diesen Fall den entsprechenden Wert der Matrix aform ein.

Funktion: av (u, v)

Eine antisymmetrische Bilinearform, die bei der Vereinfachung von Ausdrücken mit der Funktion atensimp angewendet wird. Die Funktion kann vom Nutzer durch eine neue Funktion ersetzt werden. Die Standardimplementation prüft mit der Funktion abasep, ob die Argumente u und v Basisvektoren sind und setzt für diesen Fall den entsprechenden Wert v[aform[i,j]] der Matrix aform ein.

Beispiel:

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

Funktion: abasep (v)

Prüft, ob das Argument v ein Basisvektor ist. Ein Basisvektor ist ein indiziertes Symbol mit dem Symbol asymbol als Bezeichner und einem Index im Bereich von 1 bis adim.

Beispiel:

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

[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on Juli, 9 2012 using texi2html 1.76.