(maxima.info)Functions and Variables for itensor
25.2 Functions and Variables for itensor
========================================
25.2.1 Managing indexed objects
-------------------------------
-- Function: dispcon
dispcon (<tensor_1>, <tensor_2>, ...)
dispcon (all)
Displays the contraction properties of its arguments as were given
to 'defcon'. 'dispcon (all)' displays all the contraction
properties which were defined.
-- Function: entertensor (<name>)
is a function which, by prompting, allows one to create an indexed
object called <name> with any number of tensorial and derivative
indices. Either a single index or a list of indices (which may be
null) is acceptable input (see the example under 'covdiff').
-- Function: changename (<old>, <new>, <expr>)
will change the name of all indexed objects called <old> to <new>
in <expr>. <old> may be either a symbol or a list of the form
'[<name>, <m>, <n>]' in which case only those indexed objects
called <name> with <m> covariant and <n> contravariant indices will
be renamed to <new>.
-- Function: listoftens
Lists all tensors in a tensorial expression, complete with their
indices. E.g.,
(%i6) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
k
(%t6) d e c + a b
x y i j u,v
(%i7) ishow(listoftens(%))$
k
(%t7) [a , b , c , d]
i j u,v x y
-- Function: ishow (<expr>)
displays <expr> with the indexed objects in it shown having their
covariant indices as subscripts and contravariant indices as
superscripts. The derivative indices are displayed as subscripts,
separated from the covariant indices by a comma (see the examples
throughout this document).
-- Function: indices (<expr>)
Returns a list of two elements. The first is a list of the free
indices in <expr> (those that occur only once). The second is the
list of the dummy indices in <expr> (those that occur exactly
twice) as the following example demonstrates.
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%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]]
A tensor product containing the same index more than twice is
syntactically illegal. 'indices' attempts to deal with these
expressions in a reasonable manner; however, when it is called to
operate upon such an illegal expression, its behavior should be
considered undefined.
-- Function: rename
rename (<expr>)
rename (<expr>, <count>)
Returns an expression equivalent to <expr> but with the dummy
indices in each term chosen from the set '[%1, %2,...]', if the
optional second argument is omitted. Otherwise, the dummy indices
are indexed beginning at the value of <count>. Each dummy index in
a product will be different. For a sum, 'rename' will operate upon
each term in the sum resetting the counter with each term. In this
way 'rename' can serve as a tensorial simplifier. In addition, the
indices will be sorted alphanumerically (if 'allsym' is 'true')
with respect to covariant or contravariant indices depending upon
the value of 'flipflag'. If 'flipflag' is 'false' then the indices
will be renamed according to the order of the contravariant
indices. If 'flipflag' is 'true' the renaming will occur according
to the order of the covariant indices. It often happens that the
combined effect of the two renamings will reduce an expression more
than either one by itself.
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%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]),noeval$
(%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
-- Function: show (<expr>)
Displays 'expr' with the indexed objects in it shown having
covariant indices as subscripts, contravariant indices as
superscripts. The derivative indices are displayed as subscripts,
separated from the covariant indices by a comma.
-- Option variable: flipflag
Default value: 'false'
If 'false' then the indices will be renamed according to the order
of the contravariant indices, otherwise according to the order of
the covariant indices.
If 'flipflag' is 'false' then 'rename' forms a list of the
contravariant indices as they are encountered from left to right
(if 'true' then of the covariant indices). The first dummy index
in the list is renamed to '%1', the next to '%2', etc. Then
sorting occurs after the 'rename'-ing (see the example under
'rename').
-- Function: defcon
defcon (<tensor_1>)
defcon (<tensor_1>, <tensor_2>, <tensor_3>)
gives <tensor_1> the property that the contraction of a product of
<tensor_1> and <tensor_2> results in <tensor_3> with the
appropriate indices. If only one argument, <tensor_1>, is given,
then the contraction of the product of <tensor_1> with any indexed
object having the appropriate indices (say 'my_tensor') will yield
an indexed object with that name, i.e. 'my_tensor', and with a new
set of indices reflecting the contractions performed. For example,
if 'imetric:g', then 'defcon(g)' will implement the raising and
lowering of indices through contraction with the metric tensor.
More than one 'defcon' can be given for the same indexed object;
the latest one given which applies in a particular contraction will
be used. 'contractions' is a list of those indexed objects which
have been given contraction properties with 'defcon'.
-- Function: remcon
remcon (<tensor_1>, ..., <tensor_n>)
remcon (all)
Removes all the contraction properties from the (<tensor_1>, ...,
<tensor_n>). 'remcon(all)' removes all contraction properties from
all indexed objects.
-- Function: contract (<expr>)
Carries out the tensorial contractions in <expr> which may be any
combination of sums and products. This function uses the
information given to the 'defcon' function. For best results,
'expr' should be fully expanded. 'ratexpand' is the fastest way to
expand products and powers of sums if there are no variables in the
denominators of the terms. The 'gcd' switch should be 'false' if
GCD cancellations are unnecessary.
-- Function: indexed_tensor (<tensor>)
Must be executed before assigning components to a <tensor> for
which a built in value already exists as with 'ichr1', 'ichr2',
'icurvature'. See the example under 'icurvature'.
-- Function: components (<tensor>, <expr>)
permits one to assign an indicial value to an expression <expr>
giving the values of the components of <tensor>. These are
automatically substituted for the tensor whenever it occurs with
all of its indices. The tensor must be of the form
't([...],[...])' where either list may be empty. <expr> can be any
indexed expression involving other objects with the same free
indices as <tensor>. When used to assign values to the metric
tensor wherein the components contain dummy indices one must be
careful to define these indices to avoid the generation of multiple
dummy indices. Removal of this assignment is given to the function
'remcomps'.
It is important to keep in mind that 'components' cares only about
the valence of a tensor, not about any particular index ordering.
Thus assigning components to, say, 'x([i,-j],[])', 'x([-j,i],[])',
or 'x([i],[j])' all produce the same result, namely components
being assigned to a tensor named 'x' with valence '(1,1)'.
Components can be assigned to an indexed expression in four ways,
two of which involve the use of the 'components' command:
1) As an indexed expression. For instance:
(%i2) components(g([],[i,j]),e([],[i])*p([],[j]))$
(%i3) ishow(g([],[i,j]))$
i j
(%t3) e p
2) As a 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) As a function. You can use a Maxima function to specify the
components of a tensor based on its indices. For instance, the
following code assigns 'kdelta' to 'h' if 'h' has the same number
of covariant and contravariant indices and no derivative indices,
and 'g' otherwise:
(%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) Using Maxima's pattern matching capabilities, specifically the
'defrule' and 'applyb1' commands:
(%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
-- Function: remcomps (<tensor>)
Unbinds all values from <tensor> which were assigned with the
'components' function.
-- Function: showcomps (<tensor>)
Shows component assignments of a tensor, as made using the
'components' command. This function can be particularly useful
when a matrix is assigned to an indicial tensor using 'components',
as demonstrated by the following example:
(%i1) load(ctensor);
(%o1) /share/tensor/ctensor.mac
(%i2) load("itensor");
(%o2) /share/tensor/itensor.lisp
(%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
The 'showcomps' command can also display components of a tensor of
rank higher than 2.
-- Function: idummy ()
Increments 'icounter' and returns as its value an index of the form
'%n' where n is a positive integer. This guarantees that dummy
indices which are needed in forming expressions will not conflict
with indices already in use (see the example under 'indices').
-- Option variable: idummyx
Default value: '%'
Is the prefix for dummy indices (see the example under 'indices').
-- Option variable: icounter
Default value: '1'
Determines the numerical suffix to be used in generating the next
dummy index in the tensor package. The prefix is determined by the
option 'idummy' (default: '%').
-- Function: kdelta (<L1>, <L2>)
is the generalized Kronecker delta function defined in the
'itensor' package with <L1> the list of covariant indices and <L2>
the list of contravariant indices. 'kdelta([i],[j])' returns the
ordinary Kronecker delta. The command 'ev(<expr>,kdelta)' causes
the evaluation of an expression containing 'kdelta([],[])' to the
dimension of the manifold.
In what amounts to an abuse of this notation, 'itensor' also allows
'kdelta' to have 2 covariant and no contravariant, or 2
contravariant and no covariant indices, in effect providing a
co(ntra)variant "unit matrix" capability. This is strictly
considered a programming aid and not meant to imply that
'kdelta([i,j],[])' is a valid tensorial object.
-- Function: kdels (<L1>, <L2>)
Symmetrized Kronecker delta, used in some calculations. For
instance:
(%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
-- Function: levi_civita (<L>)
is the permutation (or Levi-Civita) tensor which yields 1 if the
list <L> consists of an even permutation of integers, -1 if it
consists of an odd permutation, and 0 if some indices in <L> are
repeated.
-- Function: lc2kdt (<expr>)
Simplifies expressions containing the Levi-Civita symbol,
converting these to Kronecker-delta expressions when possible. The
main difference between this function and simply evaluating the
Levi-Civita symbol is that direct evaluation often results in
Kronecker expressions containing numerical indices. This is often
undesirable as it prevents further simplification. The 'lc2kdt'
function avoids this problem, yielding expressions that are more
easily simplified with 'rename' or 'contract'.
(%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
The 'lc2kdt' function sometimes makes use of the metric tensor. If
the metric tensor was not defined previously with 'imetric', this
results in an error.
(%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
-- Function: lc_l
Simplification rule used for expressions containing the unevaluated
Levi-Civita symbol ('levi_civita'). Along with 'lc_u', it can be
used to simplify many expressions more efficiently than the
evaluation of 'levi_civita'. For example:
(%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
-- Function: lc_u
Simplification rule used for expressions containing the unevaluated
Levi-Civita symbol ('levi_civita'). Along with 'lc_u', it can be
used to simplify many expressions more efficiently than the
evaluation of 'levi_civita'. For details, see 'lc_l'.
-- Function: canten (<expr>)
Simplifies <expr> by renaming (see 'rename') and permuting dummy
indices. 'rename' is restricted to sums of tensor products in
which no derivatives are present. As such it is limited and should
only be used if 'canform' is not capable of carrying out the
required simplification.
The 'canten' function returns a mathematically correct result only
if its argument is an expression that is fully symmetric in its
indices. For this reason, 'canten' returns an error if 'allsym' is
not set to 'true'.
-- Function: concan (<expr>)
Similar to 'canten' but also performs index contraction.
25.2.2 Tensor symmetries
------------------------
-- Option variable: allsym
Default value: 'false'
If 'true' then all indexed objects are assumed symmetric in all of
their covariant and contravariant indices. If 'false' then no
symmetries of any kind are assumed in these indices. Derivative
indices are always taken to be symmetric unless 'iframe_flag' is
set to 'true'.
-- Function: decsym (<tensor>, <m>, <n>, [<cov_1>, <cov_2>, ...],
[<contr_1>, <contr_2>, ...])
Declares symmetry properties for <tensor> of <m> covariant and <n>
contravariant indices. The <cov_i> and <contr_i> are
pseudofunctions expressing symmetry relations among the covariant
and contravariant indices respectively. These are of the form
'symoper(<index_1>, <index_2>,...)' where 'symoper' is one of
'sym', 'anti' or 'cyc' and the <index_i> are integers indicating
the position of the index in the <tensor>. This will declare
<tensor> to be symmetric, antisymmetric or cyclic respectively in
the <index_i>. 'symoper(all)' is also an allowable form which
indicates all indices obey the symmetry condition. For example,
given an object 'b' with 5 covariant indices,
'decsym(b,5,3,[sym(1,2),anti(3,4)],[cyc(all)])' declares 'b'
symmetric in its first and second and antisymmetric in its third
and fourth covariant indices, and cyclic in all of its
contravariant indices. Either list of symmetry declarations may be
null. The function which performs the simplifications is 'canform'
as the example below illustrates.
(%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]], []]]
-- Function: remsym (<tensor>, <m>, <n>)
Removes all symmetry properties from <tensor> which has <m>
covariant indices and <n> contravariant indices.
-- Function: canform
canform (<expr>)
canform (<expr>, <rename>)
Simplifies <expr> by renaming dummy indices and reordering all
indices as dictated by symmetry conditions imposed on them. If
'allsym' is 'true' then all indices are assumed symmetric,
otherwise symmetry information provided by 'decsym' declarations
will be used. The dummy indices are renamed in the same manner as
in the 'rename' function. When 'canform' is applied to a large
expression the calculation may take a considerable amount of time.
This time can be shortened by calling 'rename' on the expression
first. Also see the example under 'decsym'. Note: 'canform' may
not be able to reduce an expression completely to its simplest form
although it will always return a mathematically correct result.
The optional second parameter <rename>, if set to 'false',
suppresses renaming.
25.2.3 Indicial tensor calculus
-------------------------------
-- Function: diff (<expr>, <v_1>, [<n_1>, [<v_2>, <n_2>] ...])
is the usual Maxima differentiation function which has been
expanded in its abilities for 'itensor'. It takes the derivative
of <expr> with respect to <v_1> <n_1> times, with respect to <v_2>
<n_2> times, etc. For the tensor package, the function has been
modified so that the <v_i> may be integers from 1 up to the value
of the variable 'dim'. This will cause the differentiation to be
carried out with respect to the <v_i>th member of the list
'vect_coords'. If 'vect_coords' is bound to an atomic variable,
then that variable subscripted by <v_i> will be used for the
variable of differentiation. This permits an array of coordinate
names or subscripted names like 'x[1]', 'x[2]', ... to be used.
A further extension adds the ability to 'diff' to compute
derivatives with respect to an indexed variable. In particular,
the tensor package knows how to differentiate expressions
containing combinations of the metric tensor and its derivatives
with respect to the metric tensor and its first and second
derivatives. This capability is particularly useful when
considering Lagrangian formulations of a gravitational theory,
allowing one to derive the Einstein tensor and field equations from
the action principle.
-- Function: idiff (<expr>, <v_1>, [<n_1>, [<v_2>, <n_2>] ...])
Indicial differentiation. Unlike 'diff', which differentiates with
respect to an independent variable, 'idiff)' can be used to
differentiate with respect to a coordinate. For an indexed object,
this amounts to appending the <v_i> as derivative indices.
Subsequently, derivative indices will be sorted, unless
'iframe_flag' is set to 'true'.
'idiff' can also differentiate the determinant of the metric
tensor. Thus, if 'imetric' has been bound to 'G' then
'idiff(determinant(g),k)' will return '2 * determinant(g) *
ichr2([%i,k],[%i])' where the dummy index '%i' is chosen
appropriately.
-- Function: liediff (<v>, <ten>)
Computes the Lie-derivative of the tensorial expression <ten> with
respect to the vector field <v>. <ten> should be any indexed
tensor expression; <v> should be the name (without indices) of a
vector field. For example:
(%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
-- Function: rediff (<ten>)
Evaluates all occurrences of the 'idiff' command in the tensorial
expression <ten>.
-- Function: undiff (<expr>)
Returns an expression equivalent to <expr> but with all derivatives
of indexed objects replaced by the noun form of the 'idiff'
function. Its arguments would yield that indexed object if the
differentiation were carried out. This is useful when it is
desired to replace a differentiated indexed object with some
function definition resulting in <expr> and then carry out the
differentiation by saying 'ev(<expr>, idiff)'.
-- Function: evundiff (<expr>)
Equivalent to the execution of 'undiff', followed by 'ev' and
'rediff'.
The point of this operation is to easily evalute expressions that
cannot be directly evaluated in derivative form. For instance, the
following causes an error:
(%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.
However, if 'icurvature' is entered in noun form, it can be
evaluated using 'evundiff':
(%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
Note: In earlier versions of Maxima, derivative forms of the
Christoffel-symbols also could not be evaluated. This has been
fixed now, so 'evundiff' is no longer necessary for expressions
like this:
(%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
-- Function: flush (<expr>, <tensor_1>, <tensor_2>, ...)
Set to zero, in <expr>, all occurrences of the <tensor_i> that have
no derivative indices.
-- Function: flushd (<expr>, <tensor_1>, <tensor_2>, ...)
Set to zero, in <expr>, all occurrences of the <tensor_i> that have
derivative indices.
-- Function: flushnd (<expr>, <tensor>, <n>)
Set to zero, in <expr>, all occurrences of the differentiated
object <tensor> that have <n> or more derivative indices as the
following example demonstrates.
(%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
-- Function: coord (<tensor_1>, <tensor_2>, ...)
Gives <tensor_i> the coordinate differentiation property that the
derivative of contravariant vector whose name is one of the
<tensor_i> yields a Kronecker delta. For example, if 'coord(x)'
has been done then 'idiff(x([],[i]),j)' gives 'kdelta([i],[j])'.
'coord' is a list of all indexed objects having this property.
-- Function: remcoord
remcoord (<tensor_1>, <tensor_2>, ...)
remcoord (all)
Removes the coordinate differentiation property from the 'tensor_i'
that was established by the function 'coord'. 'remcoord(all)'
removes this property from all indexed objects.
-- Function: makebox (<expr>)
Display <expr> in the same manner as 'show'; however, any tensor
d'Alembertian occurring in <expr> will be indicated using the
symbol '[]'. For example, '[]p([m],[n])' represents
'g([],[i,j])*p([m],[n],i,j)'.
-- Function: conmetderiv (<expr>, <tensor>)
Simplifies expressions containing ordinary derivatives of both
covariant and contravariant forms of the metric tensor (the current
restriction). For example, 'conmetderiv' can relate the derivative
of the contravariant metric tensor with the Christoffel symbols as
seen from the following:
(%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
-- Function: simpmetderiv
simpmetderiv (<expr>)
simpmetderiv (<expr>[, <stop>])
Simplifies expressions containing products of the derivatives of
the metric tensor. Specifically, 'simpmetderiv' recognizes two
identities:
ab ab ab a
g g + g g = (g g ) = (kdelta ) = 0
,d bc bc,d bc ,d c ,d
hence
ab ab
g g = - g g
,d bc bc,d
and
ab ab
g g = g g
,j ab,i ,i ab,j
which follows from the symmetries of the Christoffel symbols.
The 'simpmetderiv' function takes one optional parameter which,
when present, causes the function to stop after the first
successful substitution in a product expression. The
'simpmetderiv' function also makes use of the global variable
<flipflag> which determines how to apply a "canonical" ordering to
the product indices.
Put together, these capabilities can be used to achieve powerful
simplifications that are difficult or impossible to accomplish
otherwise. This is demonstrated through the following example that
explicitly uses the partial simplification features of
'simpmetderiv' to obtain a contractible expression:
(%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
See also 'weyl.dem' for an example that uses 'simpmetderiv' and
'conmetderiv' together to simplify contractions of the Weyl tensor.
-- Function: flush1deriv (<expr>, <tensor>)
Set to zero, in 'expr', all occurrences of 'tensor' that have
exactly one derivative index.
25.2.4 Tensors in curved spaces
-------------------------------
-- Function: imetric (<g>)
-- System variable: imetric
Specifies the metric by assigning the variable 'imetric:<g>' in
addition, the contraction properties of the metric <g> are set up
by executing the commands 'defcon(<g>), defcon(<g>, <g>, kdelta)'.
The variable 'imetric' (unbound by default), is bound to the
metric, assigned by the 'imetric(<g>)' command.
-- Function: idim (<n>)
Sets the dimensions of the metric. Also initializes the
antisymmetry properties of the Levi-Civita symbols for the given
dimension.
-- Function: ichr1 ([<i>, <j>, <k>])
Yields the Christoffel symbol of the first kind via the definition
(g + g - g )/2 .
ik,j jk,i ij,k
To evaluate the Christoffel symbols for a particular metric, the
variable 'imetric' must be assigned a name as in the example under
'chr2'.
-- Function: ichr2 ([<i>, <j>], [<k>])
Yields the Christoffel symbol of the second kind defined by the
relation
ks
ichr2([i,j],[k]) = g (g + g - g )/2
is,j js,i ij,s
-- Function: icurvature ([<i>, <j>, <k>], [<h>])
Yields the Riemann curvature tensor in terms of the Christoffel
symbols of the second kind ('ichr2'). The following notation is
used:
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
-- Function: covdiff (<expr>, <v_1>, <v_2>, ...)
Yields the covariant derivative of <expr> with respect to the
variables <v_i> in terms of the Christoffel symbols of the second
kind ('ichr2'). In order to evaluate these, one should use
'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)
-- Function: lorentz_gauge (<expr>)
Imposes the Lorentz condition by substituting 0 for all indexed
objects in <expr> that have a derivative index identical to a
contravariant index.
-- Function: igeodesic_coords (<expr>, <name>)
Causes undifferentiated Christoffel symbols and first derivatives
of the metric tensor vanish in <expr>. The <name> in the
'igeodesic_coords' function refers to the metric <name> (if it
appears in <expr>) while the connection coefficients must be called
with the names 'ichr1' and/or 'ichr2'. The following example
demonstrates the verification of the cyclic identity satisfied by
the Riemann curvature tensor using the 'igeodesic_coords' function.
(%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
25.2.5 Moving frames
--------------------
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
-- Function: iframes ()
Since in this version of Maxima, contraction identities for 'ifr'
and 'ifri' are always defined, as is the frame bracket ('ifb'),
this function does nothing.
-- Variable: ifb
The frame bracket. The contribution of the frame metric to the
connection coefficients is expressed using the frame bracket:
- ifb + ifb + ifb
c a b b c a a b c
ifc1 = --------------------------------
abc 2
The frame bracket itself is defined in terms of the frame field and
frame metric. Two alternate methods of computation are used
depending on the value of 'frame_bracket_form'. If true (the
default) or if the 'itorsion_flag' is 'true':
d e f
ifb = ifr ifr (ifri - ifri - ifri itr )
abc b c a d,e a e,d a f d e
Otherwise:
e d d e
ifb = (ifr ifr - ifr ifr ) ifri
abc b c,e b,e c a d
-- Variable: icc1
Connection coefficients of the first kind. In 'itensor', defined
as
icc1 = ichr1 - ikt1 - inmc1
abc abc abc abc
In this expression, if 'iframe_flag' is true, the
Christoffel-symbol 'ichr1' is replaced with the frame connection
coefficient 'ifc1'. If 'itorsion_flag' is 'false', 'ikt1' will be
omitted. It is also omitted if a frame base is used, as the
torsion is already calculated as part of the frame bracket.
Lastly, of 'inonmet_flag' is 'false', 'inmc1' will not be present.
-- Variable: icc2
Connection coefficients of the second kind. In 'itensor', defined
as
c c c c
icc2 = ichr2 - ikt2 - inmc2
ab ab ab ab
In this expression, if 'iframe_flag' is true, the
Christoffel-symbol 'ichr2' is replaced with the frame connection
coefficient 'ifc2'. If 'itorsion_flag' is 'false', 'ikt2' will be
omitted. It is also omitted if a frame base is used, as the
torsion is already calculated as part of the frame bracket.
Lastly, of 'inonmet_flag' is 'false', 'inmc2' will not be present.
-- Variable: ifc1
Frame coefficient of the first kind (also known as Ricci-rotation
coefficients.) This tensor represents the contribution of the
frame metric to the connection coefficient of the first kind.
Defined as:
- ifb + ifb + ifb
c a b b c a a b c
ifc1 = --------------------------------
abc 2
-- Variable: ifc2
Frame coefficient of the second kind. This tensor represents the
contribution of the frame metric to the connection coefficient of
the second kind. Defined as a permutation of the frame bracket
('ifb') with the appropriate indices raised and lowered as
necessary:
c cd
ifc2 = ifg ifc1
ab abd
-- Variable: ifr
The frame field. Contracts with the inverse frame field ('ifri')
to form the frame metric ('ifg').
-- Variable: ifri
The inverse frame field. Specifies the frame base (dual basis
vectors). Along with the frame metric, it forms the basis of all
calculations based on frames.
-- Variable: ifg
The frame metric. Defaults to 'kdelta', but can be changed using
'components'.
-- Variable: ifgi
The inverse frame metric. Contracts with the frame metric ('ifg')
to 'kdelta'.
-- Option variable: iframe_bracket_form
Default value: 'true'
Specifies how the frame bracket ('ifb') is computed.
25.2.6 Torsion and nonmetricity
-------------------------------
Maxima can now take into account torsion and nonmetricity. When the
flag 'itorsion_flag' is set to 'true', the contribution of torsion is
added to the connection coefficients. Similarly, when the flag
'inonmet_flag' is true, nonmetricity components are included.
-- Variable: inm
The nonmetricity vector. Conformal nonmetricity is defined through
the covariant derivative of the metric tensor. Normally zero, the
metric tensor's covariant derivative will evaluate to the following
when 'inonmet_flag' is set to 'true':
g =- g inm
ij;k ij k
-- Variable: inmc1
Covariant permutation of the nonmetricity vector components.
Defined as
g inm - inm g - g inm
ab c a bc ac b
inmc1 = ------------------------------
abc 2
(Substitute 'ifg' in place of 'g' if a frame metric is used.)
-- Variable: inmc2
Contravariant permutation of the nonmetricity vector components.
Used in the connection coefficients if 'inonmet_flag' is 'true'.
Defined as:
c c cd
-inm kdelta - kdelta inm + g inm g
c a b a b d ab
inmc2 = -------------------------------------------
ab 2
(Substitute 'ifg' in place of 'g' if a frame metric is used.)
-- Variable: ikt1
Covariant permutation of the torsion tensor (also known as
contorsion). Defined as:
d d d
-g itr - g itr - itr g
ad cb bd ca ab cd
ikt1 = ----------------------------------
abc 2
(Substitute 'ifg' in place of 'g' if a frame metric is used.)
-- Variable: ikt2
Contravariant permutation of the torsion tensor (also known as
contorsion). Defined as:
c cd
ikt2 = g ikt1
ab abd
(Substitute 'ifg' in place of 'g' if a frame metric is used.)
-- Variable: itr
The torsion tensor. For a metric with torsion, repeated covariant
differentiation on a scalar function will not commute, as
demonstrated by the following example:
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%i2) imetric:g;
(%o2) g
(%i3) covdiff( covdiff( f( [], []), i), j)
- covdiff( covdiff( f( [], []), j), i)$
(%i4) ishow(%)$
%4 %2
(%t4) f ichr2 - f ichr2
,%4 j i ,%2 i j
(%i5) canform(%);
(%o5) 0
(%i6) itorsion_flag:true;
(%o6) true
(%i7) covdiff( covdiff( f( [], []), i), j)
- covdiff( covdiff( f( [], []), j), i)$
(%i8) ishow(%)$
%8 %6
(%t8) f icc2 - f icc2 - f + f
,%8 j i ,%6 i j ,j i ,i j
(%i9) ishow(canform(%))$
%1 %1
(%t9) f icc2 - f icc2
,%1 j i ,%1 i j
(%i10) ishow(canform(ev(%,icc2)))$
%1 %1
(%t10) f ikt2 - f ikt2
,%1 i j ,%1 j i
(%i11) ishow(canform(ev(%,ikt2)))$
%2 %1 %2 %1
(%t11) f g ikt1 - f g ikt1
,%2 i j %1 ,%2 j i %1
(%i12) ishow(factor(canform(rename(expand(ev(%,ikt1))))))$
%3 %2 %1 %1
f g g (itr - itr )
,%3 %2 %1 j i i j
(%t12) ------------------------------------
2
(%i13) decsym(itr,2,1,[anti(all)],[]);
(%o13) done
(%i14) defcon(g,g,kdelta);
(%o14) done
(%i15) subst(g,nounify(g),%th(3))$
(%i16) ishow(canform(contract(%)))$
%1
(%t16) - f itr
,%1 i j
25.2.7 Exterior algebra
-----------------------
The 'itensor' package can perform operations on totally antisymmetric
covariant tensor fields. A totally antisymmetric tensor field of rank
(0,L) corresponds with a differential L-form. On these objects, a
multiplication operation known as the exterior product, or wedge
product, is defined.
Unfortunately, not all authors agree on the definition of the wedge
product. Some authors prefer a definition that corresponds with the
notion of antisymmetrization: in these works, the wedge product of two
vector fields, for instance, would be defined as
a a - a a
i j j i
a /\ a = -----------
i j 2
More generally, the product of a p-form and a q-form would be defined
as
1 k1..kp l1..lq
A /\ B = ------ D A B
i1..ip j1..jq (p+q)! i1..ip j1..jq k1..kp l1..lq
where 'D' stands for the Kronecker-delta.
Other authors, however, prefer a "geometric" definition that
corresponds with the notion of the volume element:
a /\ a = a a - a a
i j i j j i
and, in the general case
1 k1..kp l1..lq
A /\ B = ----- D A B
i1..ip j1..jq p! q! i1..ip j1..jq k1..kp l1..lq
Since 'itensor' is a tensor algebra package, the first of these two
definitions appears to be the more natural one. Many applications,
however, utilize the second definition. To resolve this dilemma, a flag
has been implemented that controls the behavior of the wedge product: if
'igeowedge_flag' is 'false' (the default), the first, "tensorial"
definition is used, otherwise the second, "geometric" definition will be
applied.
-- Operator: ~
The wedge product operator is denoted by the tilde '~'. This is a
binary operator. Its arguments should be expressions involving
scalars, covariant tensors of rank one, or covariant tensors of
rank 'l' that have been declared antisymmetric in all covariant
indices.
The behavior of the wedge product operator is controlled by the
'igeowedge_flag' flag, as in the following example:
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%i2) ishow(a([i])~b([j]))$
a b - b a
i j i j
(%t2) -------------
2
(%i3) decsym(a,2,0,[anti(all)],[]);
(%o3) done
(%i4) ishow(a([i,j])~b([k]))$
a b + b a - a b
i j k i j k i k j
(%t4) ---------------------------
3
(%i5) igeowedge_flag:true;
(%o5) true
(%i6) ishow(a([i])~b([j]))$
(%t6) a b - b a
i j i j
(%i7) ishow(a([i,j])~b([k]))$
(%t7) a b + b a - a b
i j k i j k i k j
-- Operator: |
The vertical bar '|' denotes the "contraction with a vector" binary
operation. When a totally antisymmetric covariant tensor is
contracted with a contravariant vector, the result is the same
regardless which index was used for the contraction. Thus, it is
possible to define the contraction operation in an index-free
manner.
In the 'itensor' package, contraction with a vector is always
carried out with respect to the first index in the literal sorting
order. This ensures better simplification of expressions involving
the '|' operator. For instance:
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%i2) decsym(a,2,0,[anti(all)],[]);
(%o2) done
(%i3) ishow(a([i,j],[])|v)$
%1
(%t3) v a
%1 j
(%i4) ishow(a([j,i],[])|v)$
%1
(%t4) - v a
%1 j
Note that it is essential that the tensors used with the '|'
operator be declared totally antisymmetric in their covariant
indices. Otherwise, the results will be incorrect.
-- Function: extdiff (<expr>, <i>)
Computes the exterior derivative of <expr> with respect to the
index <i>. The exterior derivative is formally defined as the
wedge product of the partial derivative operator and a differential
form. As such, this operation is also controlled by the setting of
'igeowedge_flag'. For instance:
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%i2) ishow(extdiff(v([i]),j))$
v - v
j,i i,j
(%t2) -----------
2
(%i3) decsym(a,2,0,[anti(all)],[]);
(%o3) done
(%i4) ishow(extdiff(a([i,j]),k))$
a - a + a
j k,i i k,j i j,k
(%t4) ------------------------
3
(%i5) igeowedge_flag:true;
(%o5) true
(%i6) ishow(extdiff(v([i]),j))$
(%t6) v - v
j,i i,j
(%i7) ishow(extdiff(a([i,j]),k))$
(%t7) - (a - a + a )
k j,i k i,j j i,k
-- Function: hodge (<expr>)
Compute the Hodge-dual of <expr>. For instance:
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%i2) imetric(g);
(%o2) done
(%i3) idim(4);
(%o3) done
(%i4) icounter:100;
(%o4) 100
(%i5) decsym(A,3,0,[anti(all)],[])$
(%i6) ishow(A([i,j,k],[]))$
(%t6) A
i j k
(%i7) ishow(canform(hodge(%)))$
%1 %2 %3 %4
levi_civita g A
%1 %102 %2 %3 %4
(%t7) -----------------------------------------
6
(%i8) ishow(canform(hodge(%)))$
%1 %2 %3 %8 %4 %5 %6 %7
(%t8) levi_civita levi_civita g
%1 %106
g g g A /6
%2 %107 %3 %108 %4 %8 %5 %6 %7
(%i9) lc2kdt(%)$
(%i10) %,kdelta$
(%i11) ishow(canform(contract(expand(%))))$
(%t11) - A
%106 %107 %108
-- Option variable: igeowedge_flag
Default value: 'false'
Controls the behavior of the wedge product and exterior derivative.
When set to 'false' (the default), the notion of differential forms
will correspond with that of a totally antisymmetric covariant
tensor field. When set to 'true', differential forms will agree
with the notion of the volume element.
25.2.8 Exporting TeX expressions
--------------------------------
The 'itensor' package provides limited support for exporting tensor
expressions to TeX. Since 'itensor' expressions appear as function
calls, the regular Maxima 'tex' command will not produce the expected
output. You can try instead the 'tentex' command, which attempts to
translate tensor expressions into appropriately indexed TeX objects.
-- Function: tentex (<expr>)
To use the 'tentex' function, you must first load 'tentex', as in
the following example:
(%i1) load("itensor");
(%o1) /share/tensor/itensor.lisp
(%i2) load(tentex);
(%o2) /share/tensor/tentex.lisp
(%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.
25.2.9 Interfacing with ctensor
-------------------------------
The 'itensor' package has the ability to generate Maxima code that can
then be executed in the context of the 'ctensor' package. The function
that performs this task is 'ic_convert'.
-- Function: ic_convert (<eqn>)
Converts the 'itensor' equation <eqn> to a 'ctensor' assignment
statement. Implied sums over dummy indices are made explicit while
indexed objects are transformed into arrays (the array subscripts
are in the order of covariant followed by contravariant indices of
the indexed objects). The derivative of an indexed object will be
replaced by the noun form of 'diff' taken with respect to
'ct_coords' subscripted by the derivative index. The Christoffel
symbols 'ichr1' and 'ichr2' will be translated to 'lcs' and 'mcs',
respectively and if 'metricconvert' is 'true' then all occurrences
of the metric with two covariant (contravariant) indices will be
renamed to 'lg' ('ug'). In addition, 'do' loops will be introduced
summing over all free indices so that the transformed assignment
statement can be evaluated by just doing 'ev'. The following
examples demonstrate the features of this function.
(%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
25.2.10 Reserved words
----------------------
The following Maxima words are used by the 'itensor' package internally
and should not be redefined:
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
automatically generated by info2www version 1.2.2.9