Symmetric covariant derivatives

[Teake Nutma]

Hi everyone,

xTensor can automatically commute covariant derivatives such that they're sorted canonically (via SortCovDs), which is very convenient. However, in some cases it is actually more convenient work in a basis where covariant derivatives are symmetrized instead of sorted. So instead of doing

SortCovDs[ CD[a]@CD[b]@T[...] ] 

   -> CD[b]@CD[a]@T[...] + riemanns

I'd like to do

SymmetrizeCovDs[ CD[a]@CD[b]@T[...] ] 

   -> 1/2 ( CD[b]@CD[a]@T[...] +  CD[a]@CD[b]@T[...] ) + riemanns

and then group the symmetrized covariant derivatives into a single object such that the symmetry is manifest for xTensor. I see three possibilities of doing this:

1. Introduce a symmetric covariant derivative, CDSym.

2. Use SymManipulator for the symmetrization.

3. Symmetrically implode the derivatives into a tensor SymCDCDT.

I have written code that implements the last option, but it has the drawback that things like VarD no longer work on the symmetrically imploded tensors. (The same probably applies for using SymManipulator, but I could be wrong here). Another drawback is that you have to implode first before the imploded tensors exist.

So it seems that the best option is the first one: introducing a symmetric covariant derivative. Any thoughts on what the best way of implementing this would be?

Cheers,

Teake

[Jose]

Hi Teake,

I don't understand why the imploded method does not work. Once you have imploded tensors then you have standard tensors and everything should work fine, including variational derivatives. There must be something I'm not seeing.

I don't understand either what you mean exactly by introducing a symmetric covariant derivative. I have an explicit suggestion here (which is perhaps what you mean, but I'm not sure). Covariant derivatives already accept multiple indices, say CD[-a,-b,-c][expr], and there is no hardwired meaning for that, so you could use it to represent a symmetrized third order derivative. There is a function SymmetryGroupOfCovD[ CD[-a,-b,-c] ], which you can use to implement symmetry in the indices of the derivative. This was introduced to support the 2-index first-order derivatives of the Spinors package. Hence, if you are planning to use Spinors during your computations, do not use this method.

Hence, your suggestions 1 and 3 should work. I think using SymmetryGroupOfCovD should be simpler one to implement. I'll let Thomas discuss the possibilities with SymManipulator.

Cheers,

Jose.

[Teake Nutma]

Hi Jose,

By a symmetric covariant derivative I mean a derivative that is automatically symmetric when chained. It's not a partial derivative, but rather it would denote the symmetrization of chained 'ordinary' covariant derivative. Letting CDS indicate the symmetric version of the covariant derivative CD, we would have for instance the following equivalence relation:

CDS[a]@CDS[b]@T[...] == 1/2 ( CD[b]@CD[a]@T[...] + CD[a]@CD[b]@T[...] ) .

Furthermore, the expression CDS[a]@CDS[b]@T[...] would be automatically symmetric in the indices {a,b}.
This has the advantage over the imploded method (and over the multi-index approach) of being more easily integratable by parts. And this is what I meant by 'VarD doesn't work anymore': because the imploded tensor has absorbed the derivatives, VarD doesn't integrate by parts anymore.
Also, I don't like to break the Spinors package, so I'd prefer to stay away from multiple indices on the derivative.

In case some things are still not entirely clear, I've pasted my symmetric implode code here: http://pastebin.com/vUKwc5gX . There are two 'user' functions among the auxiliary functions: SymmetricImplode and SymmetricExplode.

Best,

Teake

> --
> You received this message because you are subscribed to the Google Groups "xAct Tensor Computer Algebra" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to xact+uns...@googlegroups.com (mailto:xact+uns...@googlegroups.com).
> For more options, visit https://groups.google.com/groups/opt_out.
>
>
>

[Thomas Bäckdahl]

Hi Teake,

Would your problem be solved if SymManipulator would be extended to work with VarD?
I suppose that it could be nice if VarD could work with arbitrary SymH objects.
The question is what would be the best way to implement this?
I suppose that we will only consider variations of scalar expressions, so all indices are dummy indices.
This means that one can move the symmetrization from the original symmetrized indices to their corresponding dummy partners. I have been thinking about implementing a function like that anyway because it can be used to simplify expressions with symmetrizations.
I think that tool should be useful for the VarD computations of SymH objects, but what more is needed?
How much would these calculations change if we would just expand the symmetry before allying VarD?

Regards
Thomas

--
You received this message because you are subscribed to the Google Groups "xAct Tensor Computer Algebra" group.

To unsubscribe from this group and stop receiving emails from it, send an email to xact+uns...@googlegroups.com.

[Teake Nutma]

Hi everybody,

I’ve finally followed Jose’s suggestion and implemented symmetrized covariant derivatives using multiple indices (so CD[a,b]@expr means for example 1/2 CD[a]@CD[b]@expr + 1/2 CD[b]@CD[a]@expr). If anyone is interested, the preliminary code and some examples can be found in this notebook:

https://github.com/xAct-contrib/xTras/raw/master/notebooks/Symmetrized%20covariant%20derivatives.nb

I’m planning on putting it into the next xTras version, and I’d be happy to get some feedback on this.

Cheers,

Teake

On Thursday 11 July 2013 at 03:16, Jose wrote:

--

[Thomas Bäckdahl]

Hi Teake!

I have only had a quick look, but this looks very interesting. There is one notational problem though. Some derivatives, for instance spinor derivatives, already have two indices. Therefore, I don't think it is a good idea to assume that if you give several indices to a derivative, that it should mean a symmetrized derivative. Perhaps some other notation can be used. What about SymCovD[CD][a,b]@T0[] instead of CD[a,b]@T0[] ? It might look a bit awkward, but it would not mess up other parts of xAct.

As a side remark, you needed to do something like
ToCanonical@Symmetrize[S2[a, b] S3[c, d, e]]
A quicker, but still general way of doing this kind of thing would be
ToCanonical@ExpandSym[ImposeSym[S2[a, b] S3[c, d, e]], SmartExpand -> True]
Your new code PartitionedSymmetrize is of course much faster yet. Nicely done.

Regards
Thomas

[Teake Nutma]

Hi Thomas,

Thanks for the heads up about the spinorial derivatives. From what I can gather from the Spinor package there shouldn’t be a conflict though. At the moment I’m using a SymCovDQ boolean function to distinguish if derivatives can be symmetrized or not. I’m planning to introduce an option to DefCovD with which you can set SymCovDQ to either True or False (I’m not yet sure what the default should be). But as spinorial derivatives are defined with DefSpinCovD, SymCovDQ will always yields False on them, and my code won’t affect their behavior.

The reason I chose not to use more complicated heads for symmetrized derivatives is that my current approach is simpler to implement (following Jose’s suggestion to use SymmetryGroupOfCovD). By the way, I started out with a separate symmetric derivative SCD for every ‘ordinary’ derivative CD, but that turned out to be unnecessarily cumbersome so I abandoned that approach. But I’m of course open to arguments in favor of other notation :).

Cheers,

Teake

[Thomas Bäckdahl]

Hi Teake!

On 2014-02-03 09:29, Teake Nutma wrote:

Hi Thomas,

Thanks for the heads up about the spinorial derivatives. From what I can gather from the Spinor package there shouldn’t be a conflict though. At the moment I’m using a SymCovDQ boolean function to distinguish if derivatives can be symmetrized or not. I’m planning to introduce an option to DefCovD with which you can set SymCovDQ to either True or False (I’m not yet sure what the default should be). But as spinorial derivatives are defined with DefSpinCovD, SymCovDQ will always yields False on them, and my code won’t affect their behavior.

I am still not convinced that it is a good idea to use the notation CD[-a,-b] here. This idea of symmetrized derivatives can also be interesting in the spinor notation, and possibly some other case too.

The reason I chose not to use more complicated heads for symmetrized derivatives is that my current approach is simpler to implement (following Jose’s suggestion to use SymmetryGroupOfCovD). By the way, I started out with a separate symmetric derivative SCD for every ‘ordinary’ derivative CD, but that turned out to be unnecessarily cumbersome so I abandoned that approach. But I’m of course open to arguments in favor of other notation :).

To define a new name for each symmetrized covd is a bit too cumbersome, especially linking SCD with CD etc.
I also think that SymmetryGroupOfCovD is the right tool. However, what I suggest is not to change the behaviour of the covariant derivative, but to introduce an operator that symmetrizes the derivative. In some sense this is similar to the way SymH gives symmetrized tensors from a list of tensors. Symmetrized derivatives should be simpler though.

For instance one could do something like
CovDQ[SymCovD[covd_?CovDQ]] ^= True;
VBundlesOfCovD[SymCovD[covd_?CovDQ]] ^:= VBundlesOfCovD[covd];
ManifoldOfCovD[SymCovD[covd_?CovDQ]] ^:= ManifoldOfCovD[covd];
SymbolOfCovD[SymCovD[covd_?CovDQ]] ^:= SymbolOfCovD[covd];
etc.

SymmetryGroupOfCovD[SymCovD[covd_?xAct`Spinors`SpinCovDQ][inds__]] ^:=
   Throw[Message[SymCovD::notyet, "SymCovD on SpinCovDs"];
   ERROR[SymCovD[covd]]];
SymmetryGroupOfCovD[SymCovD[covd_?CovDQ][inds__]] ^:=
 Symmetric[Range@Length@{inds}]
SymCovD[covd_?CovDQ][] := Identity;

This would also allow special handling for spinor derivatives etc. at some later time.

This way, one could also allow other constructions. Similarly one could for instance define AntisymCovD in the same way with
SymmetryGroupOfCovD[AntisymCovD[covd_?CovDQ][inds__]] ^:=
 Antisymmetric[Range@Length@{inds}]
Although AntisymCovD would not be as useful as SymCovD, one could use it to write the commutator without converting it into curvature.

I agree that SymCovD[CD][-a,-b] is a little bit longer to write than CD[-a,-b], but it might be worth it.
If I understand it correctly, most of these symmetrized derivatives will not be written by hand anyway, but generated by functions like SymmetrizeCovDs. The display form you have is nice compact and easy to read. It should not be too difficult to implement that for the SymCovD[CD] notation.


Regards
Thomas

[Teake Nutma]

Hi Thomas,

I see your point. But isn’t SymCovD[CD][a,b] the wrong notation for the general case if CD can have multiple indices? I think it should be SymCovD[CD][{a1,a2,…},{b1,b2,…}], which then expands to 1/2 CD[a1,a2,…]@CD[b1,b2,…] + 1/2 CD[b1,b2,…]@CD[a1,a2,…]. By the way, introducing a composite head for symmetrized derivatives gives the same cumbersomeness as introducing a different symbol for symmetrized derivatives: in both cases you want that SymCovD[CD][{a}] automatically reduces to CD[a], so you’ll need to write code for expressions which have symmetrized as well as single derivatives. If you use only one symbol that can denotes both cases, the code simplifies quite a lot.

So although I agree it would in principle be nicer to support the general case, I’m not sure if it’s worth the effort. (I’m a little bit biased here, because I won’t be using symmetrized spinorial derivatives in the foreseeable future).

Best,

Teake