| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 20.1 Tensorpakete in Maxima | ||
| 20.2 Paket ITENSOR | ||
| 20.3 Paket CTENSOR | ||
| 20.4 Paket ATENSOR |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.1 Einführung in ITENSOR | ||
| 20.2.2 Funktionen und Variablen für ITENSOR |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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] | [ ? ] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
Ä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
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
Ist vergleichbar mit der Funktion canten.
Im Unterschied zu
canten werden zusätzlich Tensorverjüngungen ausgeführt.
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.
Die Liste contractions
enthält die Tensoren, die mit der Funktion
defcon die Eigenschaft einer Tensorverjüngung erhalten haben.
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.
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]]]
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
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.
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 %.
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.
Standardwert: %
Enthält den Präfix, der einem neuen Index vorangestellt wird, der mit der
Funktion idummy
gebildet wird.
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.
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]]
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
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
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.
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
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.
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
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
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
Entfernt alle Werte von den Komponenten des Tensors tensor, die einen
Wert mit der Funktion components
erhalten haben.
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.
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
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] | [ ? ] |
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.
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]], []]]
Entfernt die Symmetrieeigenschaften des Tensors tensor, der m kovariante und n kontravariante Indizes hat.
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] | [ ? ] |
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
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.
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
Wertet jedes Auftreten von Substantivformen der Funktion idiff
in
dem tensoriellem Ausdruck ten aus.
Gibt einen zum Argument expr äquivalenten Ausdruck zurück, in dem
alle Ableitungen von indizierten Größen durch Substantivformen der
Funktion idiff
ersetzt sind.
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
Alle tensoriellen Größen tensor_i die im Ausdruck expr auftreten und keine Ableitungen haben, werden zu Null gesetzt.
Alle tensoriellen Größen tensor_i die im Ausdruck expr auftreten und Ableitungen haben, werden zu Null gesetzt.
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
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]
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.
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])
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
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
Setzt alle tensoriellen Größen, die genau einen Ableitungsindex haben, auf den Wert Null.
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] | [ ? ] |
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.
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.
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.
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
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
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)
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.
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] | [ ? ] |
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
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.
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.
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
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.
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.
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
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
The frame field. Contracts with the inverse frame field (ifri) to
form the frame metric (ifg).
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.
The frame metric. Defaults to kdelta, but can be changed using
components.
The inverse frame metric. Contracts with the frame metric (ifg)
to kdelta.
Default value: true
Specifies how the frame bracket (ifb) is computed.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
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
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.)
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.)
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.)
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.)
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] | [ ? ] |
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.
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
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.
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
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
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] | [ ? ] |
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.
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] | [ ? ] |
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.
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] | [ ? ] |
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.1 Einführung in CTENSOR | ||
| 20.3.2 Funktionen und Variablen für CTENSOR |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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] | [ ? ] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
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.
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.
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] | [ ? ] |
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
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.
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.
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.
Returns the scalar curvature (obtained by contracting the Ricci tensor) of the Riemannian manifold with the given metric.
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.
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.
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.
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.
Computes the contravariant components of the Riemann
curvature tensor as array elements uriem[i,j,k,l]. These are displayed
if dis is true.
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.
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] | [ ? ] |
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()
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] | [ ? ] |
Standardwert: false
When the variable cframe_flag is set to true, the ctensor package
performs its calculations using a moving frame.
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] | [ ? ] |
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.
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
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.
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] | [ ? ] |
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.
Computes the (2,1) contortion coefficients from the torsion tensor tr.
Computes the (2,1) nonmetricity coefficients from the nonmetricity vector nm.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.)
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]]
Computes the covariant gradient of a scalar function allowing the
user to choose the corresponding vector name as the example under
contragrad illustrates.
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
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
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.
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.
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.
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.
*** 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.
*** 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] | [ ? ] |
Returns true if M is a diagonal matrix or (2D) array.
Returns true if M is a symmetric matrix or (2D) array.
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.
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
Returns a new list consisting of L with the n'th element deleted.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
ctensor 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.
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.
Causes trigonometric simplifications to be used when tensors are computed.
Presently, ctrgsimp affects only computations involving a moving frame.
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.
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.
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.
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.
Variable used for Taylor-series expansion if ctayswitch is set to
true.
Maximum power used in Taylor-series expansion when ctayswitch is
set to true.
Point around which Taylor-series expansion is carried out when
ctayswitch is set to true.
The determinant of the metric tensor lg. Computed by cmetric when
cframe_flag is set to false.
Causes rational simplification to be applied by christof.
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.
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.
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.
The covariant frame metric. By default, it is initialized to the 4-dimensional
Lorentz frame with signature (+,+,+,-). Used when cframe_flag is
true.
The inverse frame metric. Computed from lfg when cmetric is
called while cframe_flag is set to true.
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.
The covariant Riemann tensor. Computed by lriemann.
The contravariant Riemann tensor. Computed by uriemann.
The mixed Ricci-tensor. Computed by ricci.
The contravariant Ricci-tensor. Computed by uricci.
The metric tensor. This tensor must be specified (as a dim by
dim matrix) before other computations can be performed.
The inverse of the metric tensor. Computed by cmetric.
The Weyl tensor. Computed by weyl.
Frame bracket coefficients, as computed by frame_bracket.
The Kretchmann invariant. Computed by rinvariant.
A Newman-Penrose null tetrad. Computed by nptetrad.
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 ]
User-supplied rank-3 tensor representing torsion. Used by contortion.
The contortion tensor, computed from tr by contortion.
User-supplied nonmetricity vector. Used by nonmetricity.
The nonmetricity coefficients, computed from nm by nonmetricity.
Variable indicating if the tensor package has been initialized. Set and used by
csetup, reset by init_ctensor.
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] | [ ? ] |
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] | [ ? ] |
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.1 Einführung in ATENSOR | ||
| 20.4.2 Funktionen und Variablen für ATENSOR |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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] | [ ? ] |
Initialisiert das Paket atensor mit der angegebenen Algebra
alg_type. Das Argument alg_type kann einen der folgenden
Werte haben:
universalEine allgemeine Algebra, für die keine Vertauschungsregeln definiert sind.
grassmannEine Graßmann-Algebra, für die die Vertauschungsregel u.v + v.u = 0
definiert ist.
cliffordEine 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.
symmetricEine symmetrische Algebra, die durch die Vertauschungsregel u.v - v.u = 0
definiert ist.
symplecticEine 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_envelopEine 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:
complexDie 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).
quaternionDie 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).
pauliDie 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).
diracDie 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).
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
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.
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
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
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
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.
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.
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
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 Crategus on Dezember, 12 2012 using texi2html 1.76.