Fermi normal coordinates
Adam
I'm just starting out with xAct (and with Mathematica) and am trying
to do a calculation in Fermi normal coordinates. This involves
splitting the indices into space and time and then expanding in the
limit of small spatial distances, but I want to keep the indices
abstract. I have defined indices on a 1D time manifold and on a 3D
spatial manifold. I'm keeping track of the expansion in powers of
small distance with a parameter lambda, and I would like partial
derivatives within the spatial manifold to always be accompanied by a
factor of 1/lambda. My question is, how do I make a rule that
accomplishes this? Defining a rule
rule = MakeRule[{PD[-a],1/lambda*PD[-a]}]
doesn't work. I've tried using a module to allow for a dummy argument
of PD, like PD[-a][f], but I can't get that to work either.
Thanks for any help.
Adam
Leo Stein
You should not need to use MakeRule for this. MakeRule is supposed to
automate checking of indices, making rules equivalent under
symmetries, etc. The rule you would like is simple enough that you can
write it by hand.
You can write:
LambdaRule = { CD[ a_ ][ expr_ ] :> 1/lambda * CD[a][expr] };
You need to have expr on the left and right hand sides of the rule,
since PD[a] is the head of expr, but you don't want (1/lambda*PD[a])
to be a head -- that doesn't make sense. Hence the above.
If you want a rule which is more careful, you can write something like
LambdaRule = { CD[ a_?TangentS`pmQ ][ expr_ ] :> 1/lambda * CD[a][expr] };
which will only match when a is an index in the tangent space of the
manifold S (assuming your spatial manifold is called S). pmQ matches
both co- and contravariant indices.
Best
Leo
Adam
thanks for the prompt reply. I should have stated that that was the
first thing I tried (without the ?TangentS`pmQ, which is helpful).
When I use that rule, like this
PD[-a][T[b, c]] //.LambdaRule
I get the following:
ReplaceRepeated::rrlim: Exiting after PD[-a][T[b,c]] scanned 65536
times.
PD[-a][T[b, c]]/\[Lambda]^65536
I don't know what to make of that.
Adam
On Oct 20, 3:59 pm, Leo Stein <leo.st...@gmail.com> wrote:
> Hi Adam,
> You should not need to use MakeRule for this. MakeRule is supposed to
> automate checking of indices, making rules equivalent under
> symmetries, etc. The rule you would like is simple enough that you can
> write it by hand.
> You can write:
> LambdaRule = { CD[ a_ ][ expr_ ] :> 1/lambda * CD[a][expr] };
> You need to have expr on the left and right hand sides of the rule,
> since PD[a] is the head of expr, but you don't want (1/lambda*PD[a])
> to be a head -- that doesn't make sense. Hence the above.
> If you want a rule which is more careful, you can write something like
> LambdaRule = { CD[ a_?TangentS`pmQ ][ expr_ ] :> 1/lambda * CD[a][expr] };
> which will only match when a is an index in the tangent space of the
> manifold S (assuming your spatial manifold is called S). pmQ matches
> both co- and contravariant indices.
>
> Best
> Leo
>
TB
The reason for this is that you used //. which uses the replacement
rule repeatedly until the expression does not change any more.
For each each replacement you get the same expression with an extra
factor lambda, but the output still contains a PD. Hence, the process
will loop indefinitely just adding more factors of lambda.
If you use /. instead you will not have this problem. Then the
replacement is done only once. Alternatively you can define another
differential operator for instance called PD2. Then you can replace PD
with PD2 in your rule that introduces the lambda.
Regards
Thomas
Alfonso García-Parrado
> thanks for the prompt reply. I should have stated that that was the
> first thing I tried (without the ?TangentS`pmQ, which is helpful).
> When I use that rule, like this
>
> PD[-a][T[b, c]] //.LambdaRule
>
> I get the following:
>
> ReplaceRepeated::rrlim: Exiting after PD[-a][T[b,c]] scanned 65536
> times.
>
> PD[-a][T[b, c]]/\[Lambda]^65536
>
> I don't know what to make of that.
>
what you are using here is "ReplaceRepeated" which keeps applying a rule
until an expression no longer changes. Your rule will never produce an
expression which remains unchanged and that's why ReplaceRepeated quits
after applying your rule 65536 times. What you need here is "ReplaceAll"
whose syntax is
PD[-a][T[b, c]] /.LambdaRule
(you just write the forward-slash once). For more information you can
check the on-line help of "ReplaceAll" and "ReplaceRepeated" in
Mathematica.
Best regards,
Alfonso.
Adam
just googled the error message.
I now have another question. I'm solving flat-space differential
equations, and my method of doing so is to decompose everything into
irreducible combinations of STF tensors. I would like to be able to
treat the STF part of a combination of tensors as a single tensorial
object, in the way that SymManipulator deals with the symmetric or
asymmetric part. Is there a simple way of doing this?
TB
Decomposition of tensors into irreducible components which are also
trace-free is in general a difficult computer algebra problem.
However, in spinor notation this is much simpler. Mainly because any
totally symmetric spinor is automatically trace-free and the space of
antisymmetric spinors is one dimensional.
The main reason I wrote the SymManipulator package was actually to
handle the symmetrized spinor expressions appearing in the irreducible
decomposition.
I have actually written a code to do the irreducible decomposition for
spinor expressions automatically, but I have not released the code
yet.
If people are interested I can release it fairly soon -- I need to
tidy it up a bit first.
Back to your question:
As far as I know there is no implementation yet that represent the STF
part of a tensor expression.
There is however the function STFPart that computes it.
My suggestion is the following:
Define a new tensor for each STF tensor you want to represent.
These tensors should of course be defined to be symmetric, but you
should also add automatic rules for the traces.
The trace-free rules can easily be constructed with the MakeRule
function.
You should also construct replacement rules that allows you to express
your STF tensors in terms of the original tensors.
Unfortunately I think you will have to compute the decomposition of
your expressions manually, but you can express them in terms of the
STF tensors.
When you want to "expand" the STF tensors, just use the replacement
rules described above.
It would be possible to write tools similar to the ones in
SymManipulator to deal with this case, but it would be fairly
complicated.
If you want shorter expressions for the STFPart using the tools from
SymManipulator you can do something like:
ToCanonical@CanonicalizeGroupInSym@ImposeSym[Expand@STFPart[TT[-a,-b,-
c],g],IndexList[-a,-b,-c]]
A computationally quicker way of producing this would be to write a
modified STFPart function that produces this thing in one step,
but I would need to take a closer look at this function to do that.
Don't hesitate to ask if you need more detailed answers or having
problems with this.
Regards
Thomas
TB
ToCanonical@CanonicalizeGroupInSym@ImposeSym[ContractMetric@STFPart[TT[-
a, -b, -c], g], IndexList[-a, -b, -c]]
Regards
Thomas
Leo Stein
auxiliary variables is a good one (assuming you have code which can go
in both directions; going from the auxiliary variables to the primary
variables is easy with STFPart, but the other way is hard).
I can give one piece of advice: build the tracefree rules by hand,
rather than using MakeRule. If you have an auxiliary tensor with many
indices which are all symmetric, then MakeRule is going to generate
very many rules, one for each pair of indices which are being
contracted. For example, if you have (0,4) tensor T[-a,-b,-c,-d] which
is completely symmetric, and you want to make rules for killing its
trace, then you would write:
MakeRule[{T[-a, a, -c, -d], 0}]
MakeRule[{met[a, b] T[-a, -b, -c, -d], 0}, MetricOn -> All]
The above generates a total of 108 rules. You really do not need that many:
T /: T[___, a_, ___, -a_, ___] := 0;
T /: T[___, -a_, ___, a_, ___] := 0;
T /: (T[___, -a_, ___, -b_, ___] met[a,b]) := 0;
T /: (T[___, -b_, ___, -a_, ___] met[a,b]) := 0;
T /: (T[___, a_, ___, b_, ___] met[-a,-b]) := 0;
T /: (T[___, b_, ___, a_, ___] met[-a,-b]) := 0;
T /: (T[___, a_, ___, -b_, ___] delta[-a,b]) := 0;
T /: (T[___, -b_, ___, -a_, ___] delta[-a,b]) := 0;
The above rules work any tensor T which is STF. I wrote them above as
automatic rules, but you could make a function returning a list of
rules, e.g. STFRules[T] which would give a list of the above as rules.
Best,
Leo