Comments on yesterday’s lecture

SetDirectory["~/Documents/Wolfram Mathematica/xAct_1.2.0"]

There was a question on Killing Vectors in xAct

<<xAct`xTras`;

?KillingVectorOf

?KillingVectorQ

I am not sure if there is a way to solve for the Killing vectors directly, though perhaps it may already exist.

Second question was about Tetrads in xAct. A simple google search gives that there indeed is a package which can be found here

http://www.xact.es/Documentation/HTML/PublicNPGHP.nb.html

There is another computer algebra system (CAS) called CADABRA which also takes care of the tetras. The older verson Cadabra1 has it explicitly functioning. Cadabra2, the newer version has a limited functionality. Cadabra is a very useful software as it allows much more flexibility to the user, but, he/she has to work more.

Finally  there was issue about working with Covariant derivatives that do not vanish when acting on the metric. I was not able to find such instances except that perhaps it calles it metric incompatible derivative e.g. the partial derivative is metric incompatible. But, this is just half an hour of search. Maybe the question can be posted in the xAct google forum

https://groups.google.com/g/xact

If there is time, we will see how to use xTras for getting e.o.m for higher order gravity theory.

Physics in the Bondi gauge using xACT

In this session we present some of the details of how we can use xAct for computations involving Bondi-gauge.

We shall be following three papers :

Aspects of the BMS/CFT correspondence by Glenn Barnich and Cedric Troessaert

The Λ-(Subscript[BMS, 4]) group of (Subscript[dS, 4]) and new boundary conditions for (Subscript[AdS, 4]) by Geoffery Compere, Adrien Fiorucci, Romain Ruzziconi

The partial bondi gauge: Further enlarging the asymptotic structure of gravity by Marc Geiller and Celine Zwikel

Our goal is to first verify the Christofell connections and the Ricci tensor given for the metric in 1. for a 4D metric in the Bondi form

(ds^2) = (e^(2β)) (V/r) (du^2) - 2 (e^(2β))du dr + (Subscript[g, AB]) ((dx^A) -(U^A)du) ((dx^B) -(U^B)du)

Note that we have (Subscript[g, rr])=0, (Subscript[g, rA])=0 and further the 2-dimensional transverse metric (Subscript[g, AB]) is subject to the following constraint

(∂_r)(((det((Subscript[g, AB])))/(r^4)))=0 <-> det((Subscript[g, AB]))=(r^4)χ(u,(x^A))

Any metric in 4-Dimensions can be brought into the above form.

β, V, (U^A) and (Subscript[g, AB]) are functions of the Bondi coordinates (u,r ,(x^A)).

The metric condition (g^AB) (∂_r)(Subscript[g, AB])= (4/r) implies that χ=det((Subscript[q, AB])),  (q^AB)(Subscript[C, AB])=0 and further leads to

(Subscript[D, AB])=(1/4)(Subscript[q, AB])(C^CD)(Subscript[C, CD]) + (Subscript[𝒟, AB]) 

(Subscript[E, AB])=(1/2)(Subscript[q, AB]) (Subscript[𝒟, CD])(C^CD)+ (Subscript[ℰ, AB])

(Subscript[F, AB])=(1/2)(Subscript[q, AB ])((C^CD) (Subscript[ℰ, CD]) + (1/2)(Subscript[𝒟, CD])(𝒟^CD)-(1/16)((((Subscript[c, CD])(c^CD)))^2))+ (Subscript[ℱ, AB]) 

with (q^AB)(Subscript[𝒟, AB])= (q^AB)(Subscript[ℰ, AB])= (q^AB)(Subscript[ℱ, AB]) =0

The basic idea is to expand all the fields i.e. β, V, (U^A) and (Subscript[g, AB]) in the radial coordinates and demand that the resulting 4 dimensional metric satisfies the  vacuum Einstein with a cosmological constant Λ<0 at various orders in (1/r). These gives rise to various constraints for these functions.

In particular we make the ansatz

(Subscript[g, AB])=(r^(2 ))((Subscript[q, AB])^( ))+r (Subscript[C, AB])+(Subscript[D, AB])+((Subscript[E, AB])/r)+((Subscript[F, AB])/(r^2))

											β= (Subscript[β, 0])+((Subscript[β, 1])/r)+((Subscript[β, 2])/(r^2))+((Subscript[β, 3])/(r^3))+ . . . .
		
											(U^A)=((Subscript[U, 0])^A)+ (((Subscript[U, 1])^A)/r)+(((Subscript[U, 2])^A)/(r^2))+ (((Subscript[U, 3])^A)/(r^3))+ . . . 
		
											V= (Subscript[V, 0])+ ((Subscript[V, 1])/r)+ ((Subscript[V, 2])/(r^2)) + ((Subscript[V, 3])/(r^3)) + .  . .   
	and substitute everything in the Einstein equation 
	
												(Subscript[G, μν])+Λ (Subscript[g, μν])=0 				μ,ν ϵ { u, r, (x^A)}
	
	and demand that order by order the constraints on the free

The system of equations above can actually be solved based on Bondi Hierarchy i.e. there is an order of solving the equations that simplifies determination of the solution space.

First we note that there are the following kinds of equations:

(Subscript[G, uu])+Λ (Subscript[g, uu])=0,        (Subscript[G, ur])+Λ (Subscript[g, ur])=0,          (Subscript[G, uA])+ Λ (Subscript[g, uA]) = 0,        (Subscript[G, rr])=0,         (Subscript[G, rA])=0,         (Subscript[G, AB]) + Λ (Subscript[g, AB])=0

First solve for equations that do not involve Λ i.e. (Subscript[G, rr])=(Subscript[R, rr])=0 and (Subscript[G, rA])=(Subscript[R, rA])=0. The former solves for β and the latter for (U^A).

Integration of the the second of the above equations leads to an integration constant (N^A) which is interpreted as angular momentum aspect. The  time evolution (∂_u) (N^A)  is determined by the  equation  (Subscript[G, uA])+ Λ (Subscript[g, uA])=0, later in the Bondi Hierarchy.

Next we solve the Λ dependent equations of motion. Fist we solve (Subscript[G, ur])+ Λ (Subscript[g, ur])=0, and its content is same at that of (Subscript[G, AB])+Λ (Subscript[g, AB]) = 0. These equations give rise to another integration constant called M, which is interpreted as the Bondi Mass.

Now we are left with (Subscript[G, uu])+Λ (Subscript[g, uu])=0 and (Subscript[G, uA])+  Λ (Subscript[g, uA]) = 0, the former of which determines the mass loss formula (∂_u)M and the latter as already mentioned the evolution of angular momentum.

This essentially is the theory. We need to implement it in xAct.

As we can see, the situation is neither fully covariant, nor fully coordinate dependent. So, we cannot exclusively use either xTensor or xCoba.

We will have to be somewhat smart to keep using the covariance in the transverse directions i.e. along (x^A).

The basic algorithm behind the partial covariance in theory

As a matrix the 4 dimensional metric in the Bondi gauge above can be written as  (({{(e^(2 β))(V/r)+({{g, ({{ ,  }, {A, B}})}}) ({{U, ({{A}, { }})}}) ({{U, ({{B}, { }})}}) , -(e^(2 β)), -(Subscript[g, BC])(U^C)}, {-(e^(2 β)), 0, 0}, {-(Subscript[g, AC])(U^C), 0, (Subscript[g, AB])}}))

The inverse of such a matrix is given by  (({{0, -(e^(-2 β)), 0}, {-(e^(-2 β)), -(V/r)(e^(-2β)), -(e^(-2 β)) (U^B)}, {0, -(U^A)(e^(-2 β)) , (g^AB)}}))

The basic idea is to treat β, V, (U^A) as fields on a two dimensional Manifold with metric (Subscript[g, AB ])and convert all the covariant all the 4D quantities, in terms of covariant derivatives and Christofell connections of the 2-dimensional transverse metric (Subscript[g, AB]). All these results are given on page 26 of [1].

The authors of [1] define the following quantities for easing the notations (Subscript[k, A B])=(1/2)(∂_r)(Subscript[g, AB]), (Subscript[l, AB])=(1/2)(∂_u)(Subscript[g, AB]) and (Subscript[n, A])=(1/2)(e^(-2β))(Subscript[g, AB])(U^B)

After this, the equations are solved using the bondi Hierarchy mentioned above with a radial expansion of the metric (Subscript[g, AB]) given above. Now the raising and lowering is done with the leading part (Subscript[q, AB]).

Coding the above in xACT

We verify using xAct the Christofell symbols and the Ricci tensor given in [1]. This we brute force by first calculating the four dimensional Christoffel connections and Ricci tensors and comparing them with [1].

Once we are confident of the expressions, we follow the Bondi Hierarchy, but, with metric as (Subscript[q, AB , ])the leading part of the full transverse metric.

In the above all the indices are raised and lowered with respect to the 2 dimensional metric (Subscript[g, AB]).

Setting up the definitions

The bondi metric can be thought of comprising the scalar field β and V and a vector field (U^A) on a two dimensional manifold with metric (Subscript[g, AB]).

We need to define the 2 dimensional manifold with metric (Subscript[g, AB]).

Next we load the only two packages that we shall need, xTensor and TexAct.

<<xAct`xTensor`;
<<xAct`TexAct`;

The $PrePrint= ScreenDollarIndices removes any dollar indices that are produced during the computation.

$PrePrint= ScreenDollarIndices

Another important command we must use is SetOptions[ToCanonical,UseMetricOnVBundle->None]

First we show below what happens if we do not use such an option

DefParameter[{u,r}];
pu[i_]:=ParamD[u][i];
pr[i_]:=ParamD[r][i];

DefManifold[M2,2,{A,B,F,G,H,L,P,Q,R,S,Z,Z0,Z1,Z2}];
DefMetric[1,g[-A,-B],CD,OtherDependencies->{r,u},PrintAs->"g"];

We have deliberately defined that the metric g depends on other parameters “r” and “u” that are not naturally part of the 2d manifold.

DefTensor[β[],{M2,u,r}];

Consider the expression

ex1=CD[-A][β[]]g[A,B]

ex1//ToCanonical

PD[-A][β[]]g[A,B]//ToCanonical

The issue is that ToCanonical tries to raise indices on the partial derivatives which is incompatible with metric. Without this warning there will be lost of errors. To prevent ToCanonical from attempting this we do the following

SetOptions[ToCanonical,UseMetricOnVBundle->None]

PD[-A][β[]]g[A,B]//ToCanonical

This time it only used the symmetry of the metric and did not attempt raising/lowering indices on the partial derivatives. Our problem involves taking many such derivatives. So, we have suppressed this feature of ToCanonical

Now we define at the scalars/tensor fields that enter the computations

A pitfall to avoid

xAct is very good at identifying an invalid tensor expression, and its manipulation.

Above we saw, how it did not blindly raise or lower indices on a partial derivative and showed us error and did not proceed further with the computation.

The command that checks the validity of an expression is  Validate

?Validate

In our program we found that xAct fails to warn the user in the following case.

DefTensor[U[A],{M2,u,r}];

ex=U[A]U[A]

This is obviously an invalid tensor expression and xAct should have warned us. In fact

ex1=U[A]U[A]//Validate

if we use the Validate command, xAct does warn us. However, look at the following case

ex2=U[A]U[-A]

ex2 ex2

This is also not correct, but, if we use Validate command, we do not get any error

ex2 ex2 //Validate

This can lead to serious error.

Fortunately there is a way around this in the form of a couple of commands called PutScalar and NoScalar

Whenever we enter a scalar expression  due to contraction and this scalar is to multiplied to itself we should use PutScalar

ex3=U[A]U[-A]//PutScalar

(ex3^3)

%//NoScalar

With these subtleties out of way, we are now ready to code.

DefTensor[V[],{M2,u,r}];

DefTensor[k[-A,-B],{M2,u,r},PrintAs->"k"];
DefTensor[l[-A,-B],{M2,u,r},PrintAs->"l"];
DefTensor[n[-A],{M2,u,r},PrintAs->"n"];

Now we set n,k,l tensors as defined by BT by making use of IndexSetDelayed. This sets l.h.s equal to r.h.s without evaluating r.h.s. This command is like := of usual Mathematica.

IndexSetDelayed[k[-A_,-B_],(1/2)pr[g[-A,-B]]];
IndexSetDelayed[l[-A_,-B_],(1/2)pu[g[-A,-B]]];
IndexSetDelayed[n[-A_],Module[{Z},(1/2)Exp[-2β[]]g[-A,-Z]pr[U[Z]]]];

DefTensor[l1[],{M2,u,r}];
DefTensor[l2[A,-B],{M2,u,r}];
DefTensor[k2[A,-B],{M2,u,r}];
IndexSet[l1[],Module[{Z0,Z1},g[Z0,Z1]l[-Z0,-Z1]]];
IndexSet[l2[A_,-B_],SeparateMetric[][l[A,-B]]];
IndexSet[k2[A_,-B_],SeparateMetric[][k[A,-B]]];

Defining the 4D metric

We view the 4D metric as comprising scalar fields β and V, a vector field (U^A) and (Subscript[g, AB]) as a metric field on a two dimensional manifold defined above.

These are arranged in a 3x3 Table. The third row and column carry an index that takes two values. This is however in our head.

We then tell Mathematica to compute the Christofell connections and the Ricci and Riemann tensors using the usual formulae (in 3D).

DefTensor[guu[],{M2,u,r},PrintAs->"(Subscript[g, uu])"];
DefTensor[gur[],{M2,u,r},PrintAs->"(Subscript[g, ur])"];
DefTensor[gua[-A],{M2,u,r},PrintAs->"(Subscript[g, u])"];
DefTensor[grr[],{M2,u,r},PrintAs->"(Subscript[g, rr])"];
DefTensor[gra[-A],{M2,u,r},PrintAs->"(Subscript[g, r])"];
DefTensor[guuu[],{M2,u,r},PrintAs->"(g^uu)"];
DefTensor[guur[],{M2,u,r},PrintAs->"(g^ur)"];
DefTensor[guua[A],{M2,u,r},PrintAs->"(g^u)"];
DefTensor[gurr[],{M2,u,r},PrintAs->"(g^rr)"];
DefTensor[gura[A],{M2,u,r},PrintAs->"(g^r)"];

We define a 3x3 list that contains the metric 2x2 metric which shall preserve 2d covariance

metlist[a_,b_]:={{guu[],gur[],gua[-b]},{gur[],grr[],gra[-b]},{gua[-a],gra[-a],g[-a,-b]}};
invmetlist[a_,b_]:={{guuu[],guur[],guua[b]},{guur[],gurr[],gura[b]},{guua[a],gura[a],g[a,b]}};

metlist[A,B]//MatrixForm

invmetlist[A,B]//MatrixForm

grrrule=MakeRule[{grr[],0},MetricOn->None];
grarule=MakeRule[{gra[-A],0},MetricOn->None];
guuurule=MakeRule[{guuu[],0},MetricOn->None];
guuarule=MakeRule[{guua[A],0},MetricOn->None];
rrule=Join[MakeRule[{PD[-A][r],0}],MakeRule[{PD[A][r],0}],MakeRule[{CD[-A][r],0}]];
urule=Join[MakeRule[{PD[-A][u],0}],MakeRule[{PD[A][u],0}]];
guurule=MakeRule[{guu[],Exp[2β[]]((V[])/r)+g[-Z0,-Z1]U[Z0]U[Z1]},MetricOn->None];
gurrule=MakeRule[{gur[],-Exp[2β[]]},MetricOn->None];
guarule=MakeRule[{gua[-A],-g[-A,-Z0]U[Z0]},MetricOn->None];
guurrule=MakeRule[{guur[],-Exp[-2β[]]},MetricOn->None];
gurrrule=MakeRule[{gurr[],-((V[])/r)Exp[-2β[]]},MetricOn->None];
gurarule=MakeRule[{gura[A],-U[A]Exp[-2β[]]},MetricOn->None];

guu[]/.guurule

bondirules=Join[guurule,gurrule,guarule,grrrule,grarule,guuurule,guurrule,guuarule,gurrrule,gurarule,rrule,urule];

metlist[A,B]//MatrixForm

Some Check of the metric

metlist[A,F]//.bondirules//ToCanonical//NoScalar//ScreenDollarIndices//MatrixForm

invmetlist[A,F]//.bondirules//ScreenDollarIndices//MatrixForm

invmetlist[A,B].metlist[B,G]//.bondirules//ToCanonical//MatrixForm

metlist[A,B].invmetlist[B,G]//.bondirules//ToCanonical//MatrixForm

Thus, we have managed to put a four dimensional metric in 3x3 table. Now the idea is to simply evaluate the Chritofell connections, the Riemann and Ricci using this 3x3 table.

der[i1_,c1_]:=Which[c1==1,ParamD[u],c1==2,ParamD[r],c1==3,PD[-i1]] 

cclist[i1_,i2_,i3_,c1_,c2_,c3_]:=Module[{Z1},Sum[(1/2) invmetlist[i1,Z1][[c1,r1]](der[i2,c2][metlist[Z1,i3][[r1,c3]]]+der[i3,c3][metlist[i2,Z1][[c2,r1]]] - der[Z1,r1][metlist[i2,i3][[c2,c3]]]),{r1,1,3}]]

Defining the Christofell symbols

DefTensor[gammauuu[],{M2,u,r},PrintAs-> "(Subscript[(Γ^u), uu])"];
DefTensor[gammauur[],{M2,u,r},PrintAs-> "(Subscript[(Γ^u), ur])"];
DefTensor[gammauuA[-A],{M2,u,r},PrintAs-> "(Subscript[(Γ^u), u])"];
DefTensor[gammaurr[],{M2,u,r},PrintAs-> "(Subscript[(Γ^u), rr])"];
DefTensor[gammaurA[-A],{M2,u,r},PrintAs-> "(Subscript[(Γ^u), r])"];
DefTensor[gammauAB[-A,-B],{M2,u,r},Symmetric[{-A,-B}],PrintAs-> "(Γ^u)"];

DefTensor[gammaruu[],{M2,u,r},PrintAs-> "(Subscript[(Γ^r), uu])"];
DefTensor[gammarur[],{M2,u,r},PrintAs-> "(Subscript[(Γ^r), ur])"];
DefTensor[gammaruA[-A],{M2,u,r},PrintAs-> "(Subscript[(Γ^r), u])"];
DefTensor[gammarrr[],{M2,u,r},PrintAs-> "(Subscript[(Γ^r), rr])"];
DefTensor[gammarrA[-A],{M2,u,r},PrintAs-> "(Subscript[(Γ^r), r])"];
DefTensor[gammarAB[-A,-B],{M2,u,r},Symmetric[{-A,-B}],PrintAs-> "(Γ^r)"];

DefTensor[gammaAuu[A],{M2,u,r},PrintAs-> "(Subscript[Γ, uu])"];
DefTensor[gammaAur[A],{M2,u,r},PrintAs-> "(Subscript[Γ, ur])"];
DefTensor[gammaAuB[A,-B],{M2,u,r},PrintAs-> "(Subscript[Γ, u])"];
DefTensor[gammaArr[A],{M2,u,r},PrintAs-> "(Subscript[Γ, rr])"];
DefTensor[gammaArB[A,-B],{M2,u,r},PrintAs-> "(Subscript[Γ, r])"];
DefTensor[gammaABF[A,-B,-F],{M2,u,r},Symmetric[{-B,-F}],PrintAs-> "Γ"];

gammauuu[]

gammaArB[A,-F]

gammaABF[A,-F,-G]

At this point we could in principle use MakeRule that sets these Christofell “tensors” defined above to equal the 4D Christofell connections we calculated brute force. 
This however does not work e.g.  
MakeRule[{gammaurA[-A],cslist[1,2,A,1,2,3]}]
(MessageTemplate2[MakeRule, inhom, "Inhomogeneous indices in rule: \!\(\*RowBox[{\"{\", RowBox[{\"-\", \"A\"}], \"}\"}]\), \!\(\*RowBox[{\"{\", \"}\"}]\).", , , , , Local, xAct`xTensor`MakeRule])
(MessageTemplate[Throw, nocatch, "Uncaught \!\(\*RowBox[{\"Throw\", \"[\", \"Null\", \"]\"}]\) returned to top level.", , , , , Local])
Hold[Throw[Null]]
So, the r.h.s must also have same tensor structure for MakeRule to work.
We define some temporary Christofell symbol and assign to them the Christofell connections found above by making use of IndexSet
IndexSet does not care about the index structure. 
After this we can MakeRule for Christofell connections by setting them equal to the temporary Christofell defined above. 
Let us see this in practise.

Defininng the temporary Christofell symbol in order to MakeRule

DefTensor[tcsuuu[],{M2,u,r}];
DefTensor[tcsuur[],{M2,u,r}];
DefTensor[tcsurr[],{M2,u,r}];
DefTensor[tcsuuA[-A],{M2,u,r}];
DefTensor[tcsurA[-A],{M2,u,r}];
DefTensor[tcsuAB[-A,-B],{M2,u,r}];

DefTensor[tcsruu[],{M2,u,r}];
DefTensor[tcsrur[],{M2,u,r}];
DefTensor[tcsruA[-A],{M2,u,r}];
DefTensor[tcsrrr[],{M2,u,r}];
DefTensor[tcsrrA[-A],{M2,u,r}]
DefTensor[tcsrAB[-A,-B],{M2,u,r}];


DefTensor[tcsAuu[A],{M2,u,r}];
DefTensor[tcsAur[A],{M2,u,r}];
DefTensor[tcsAuB[A,-B],{M2,u,r}];
DefTensor[tcsArr[A],{M2,u,r}];
DefTensor[tcsArB[A,-B],{M2,u,r}];
DefTensor[tcsABF[A,-B,-F],{M2,u,r}];

List for the Chirstofell symobls

cslist[a_,b_,c_]:={{{gammauuu[],gammauur[],gammauuA[-c]},{gammauur[],gammaurr[],gammaurA[-c]},{gammauuA[-b],gammaurA[-b],gammauAB[-b,-c]}},
{{gammaruu[],gammarur[],gammaruA[-c]},{gammarur[],gammarrr[],gammarrA[-c]},{gammaruA[-b],gammarrA[-b],gammarAB[-b,-c]}},
{{gammaAuu[a],gammaAur[a],gammaAuB[a,-c]},{gammaAur[a],gammaArr[a],gammaArB[a,-c]},{gammaAuB[a,-b],gammaArB[a,-b],gammaABF[a,-b,-c]}}}

Calculating the temporary Christofell symbols

Tcsuuu=IndexSet[tcsuuu[],cclist[1,1,1,1,1,1]//.bondirules//ToCanonical];
Tcsuur=IndexSet[tcsuur[],cclist[1,1,2,1,1,2]//.bondirules//ToCanonical];
TcsuuA=IndexSet[tcsuuA[-A_],cclist[1,1,A,1,1,3]//.bondirules//ToCanonical];
Tcsurr=IndexSet[tcsurr[],cclist[1,2,2,1,2,2]//.bondirules//ToCanonical];
TcsurA=IndexSet[tcsurA[-A_],cclist[1,2,A,1,2,3]//.bondirules//ToCanonical];
TcsuAB=IndexSet[tcsuAB[-A_,-B_],cclist[1,A,B,1,3,3]//.bondirules//ToCanonical];
Tcsruu=IndexSet[tcsruu[],cclist[2,1,1,2,1,1]//.bondirules//ToCanonical];
Tcsrur=IndexSet[tcsrur[],cclist[2,1,2,2,1,2]//.bondirules//ToCanonical];
TcsruA=IndexSet[tcsruA[-A_],cclist[2,1,A,2,1,3]//.bondirules//ToCanonical];
Tcsrrr=IndexSet[tcsrrr[],cclist[2,2,2,2,2,2]//.bondirules//ToCanonical];
TcsrrA=IndexSet[tcsrrA[-A_],cclist[2,2,A,2,2,3]//.bondirules//ToCanonical];
TcsrAB=IndexSet[tcsrAB[-A_,-B_],cclist[2,A,B,2,3,3]//.bondirules//ToCanonical];
TcsAuu=IndexSet[tcsAuu[A_],cclist[A,1,1,3,1,1]//.bondirules//ToCanonical];
TcsAur=IndexSet[tcsAur[A_],cclist[A,1,2,3,1,2]//.bondirules//ToCanonical];
TcsAuB=IndexSet[tcsAuB[A_,-B_],cclist[A,1,B,3,1,3]//.bondirules//ToCanonical];
TcsArr=IndexSet[tcsArr[A_],cclist[A,2,2,3,2,2]//.bondirules//ToCanonical];
TcsArB=IndexSet[tcsArB[A_,-B_],cclist[A,2,B,3,2,3]//.bondirules//ToCanonical];
TcsABF=IndexSet[tcsABF[A_,-B_,-F_],cclist[A,B,F,3,3,3]//.bondirules//ToCanonical];

Checking the Christofell Connection given in the Barnich, Toessaert paper

g111a=cclist[1,1,1,1,1,1]//.bondirules;
g111b=2pu[β[]]+(1/2)(pr[((V[])/r)]+2pr[β[]] ((V[])/r))+2U[A]n[-A]+Exp[-2β[]]k[-A,-B]U[A]U[B]//Simplify;
g111c=g111a-g111b//NoScalar//ToCanonical

g112a=cclist[1,1,2,1,1,2]/.bondirules

g113a=cclist[1,1,A,1,1,3]/.bondirules;
g113b=PD[-A][β[]]-n[-A]-Exp[-2β[]]k[-A,-B]U[B];
g113c=ToCanonical[g113a-g113b]

g122a=cclist[1,2,2,1,2,2]/.bondirules

g123a=cclist[1,2,A,1,2,3]/.bondirules

g131a=cclist[1,A,1,1,3,1]/.bondirules

This should be same as g113a and we verify this explcicity by

g131a-g113a//ToCanonical

g132a=cclist[1,A,2,1,3,2]/.bondirules

g133a=cclist[1,A,B,1,3,3]/.bondirules;
g133b=Exp[-2β[]]k[-A,-B];
g133c=g133a-g133b

g211a=cclist[2,1,1,2,1,1]//.bondirules//ContractMetric//ToCanonical;
g211b=-(1/2)(pu[((V[])/r)]-2pu[β[]]((V[])/r))+(1/2)((V[])/r)(pr[((V[])/r)]+2pr[β[]]((V[])/r))+(1/2)U[A](PD[-A][((V[])/r)]+2PD[-A][β[]]((V[])/r))+2((V[])/r)U[A]n[-A]+((V[])/r)Exp[-2β[]]k[-A,-B]U[A]U[B]+Exp[-2β[]]l[-A,-B]U[A]U[B]+Exp[-2β[]]U[A]U[B]CD[-A][U[-B]]//.bondirules//CovDToChristoffel//ChristoffelToMetric//ContractMetric//ToCanonical;
g211c=SeparateMetric[][g211a-g211b]//ToCanonical

g212a=cclist[2,1,2,2,1,2]/.bondirules;
g212b=-(1/2)(pr[((V[])/r)]+2pr[β[]]((V[])/r))-(PD[-A][β[]]U[A]+n[-A]U[A])//Simplification;
g212c=g212a-g212b//ToCanonical

g213a=cclist[2,1,A,2,1,3]//.bondirules//Simplification;
g213b= -(((PD[-A][V[]])/(2r))+((V[])/r)n[-A]+Exp[-2β[]]U[B]((1/2)CD[-A][U[-B]]+(1/2)CD[-B][U[-A]]+l[-A,-B]+((V[])/r)k[-A,-B]))//CovDToChristoffel//ChristoffelToMetric//Simplification;
g213c=g213a-g213b//ContractMetric//ToCanonical

SeparateMetric[][g213c]//ToCanonical

g221a=cclist[2,2,1,2,2,1]//.bondirules//Simplification

This must be same as g212a which we verify below

g212a-g221a//ToCanonical

g222a=cclist[2,2,2,2,2,2]//.bondirules//Simplification

This is as given in the paper

g223a=cclist[2,2,A,2,2,3]//.bondirules//Simplification;
g223b=PD[-A][β[]]+n[-A];
g223c=g223a-g223b//ToCanonical

g233a=cclist[2,A,B,2,3,3]//.bondirules;
g233b=Exp[-2β[]]((1/2)CD[-A][U[-B]]+(1/2)CD[-B][U[-A]]+l[-A,-B]+k[-A,-B]((V[])/r))/.bondirules//CovDToChristoffel//ChristoffelToMetric//ContractMetric;
g233c=SeparateMetric[][g233a-g233b]//ToCanonical

g311a=cclist[A,1,1,3,1,1]//.bondirules;
g311b=2U[A]pu[β[]]+(1/2)U[A](pr[((V[])/r)]+2pr[β[]]((V[])/r))+2U[A]n[-B]U[B]+ U[A]k[-B,-G]Exp[-2β[]]U[B]U[G]-pu[U[A]]-2l[A,-B]U[B]-(1/2)Exp[2β[]](PD[A][((V[])/r)]+2PD[A][β[]]((V[])/r))-(1/2)CD[A][U[G]U[-G]]//CovDToChristoffel//ChristoffelToMetric//ToCanonical;
g311c=g311a-g311b//.bondirules//ContractMetric

SeparateMetric[][g311c]//ToCanonical

g312a=cclist[A,1,2,3,1,2]//.bondirules//ContractMetric;
g312b=SeparateMetric[][-k[A,-B]U[B]+Exp[2β[]](PD[A][β[]]-n[A])];
g312c=g312a-g312b//ContractMetric//ToCanonical

g313a=cclist[A,1,B,3,1,3]/.bondirules//ContractMetric

This is same as g331 wich we calculate below and show equals the expression in the Barnich, Troessaert paper.

g321 if same as g312 will give autmatically verify for g321.

cclist[A,2,1,3,2,1]-cclist[A,2,1,3,1,2]

g322a=cclist[A,2,2,3,2,2]/.bondirules

g323 is same as g332 and it will be verified below

g323a=cclist[A,2,B,3,2,3]/.bondirules

g331a=cclist[A,B,1,3,3,1]/.bondirules//ContractMetric;
g331b=l[A,-B]+(1/2)CD[A][U[-B]]-(1/2)CD[-B][U[A]]+U[A](PD[-B][β[]]-n[-B])-Exp[-2β[]]k[-B,-G]U[A]U[G]//CovDToChristoffel//ChristoffelToMetric;
g331c=SeparateMetric[][g331a-g331b]//ToCanonical

g333a=cclist[A,B,F,3,3,3]/.bondirules;
g333b=Exp[-2β[]]U[A]k[-B,-F]+ChristoffelCD[A,-B,-F]//ChristoffelToMetric;
g333c=g333a-g333b//ToCanonical

Checking if the stored values of christofell are entered correctly

g111a-Tcsuuu//NoScalar//ToCanonical

g112a-Tcsuur

g113a-TcsuuA//NoScalar//ToCanonical

g122a-Tcsurr

g123a-TcsurA

g133a-TcsuAB//NoScalar//ToCanonical

SeparateMetric[][g211a-Tcsruu]//NoScalar//ToCanonical

g212a-Tcsrur//NoScalar//ToCanonical

g213a-TcsruA//NoScalar//ToCanonical

g222a-Tcsrrr//NoScalar//ToCanonical

g223a-TcsrrA//NoScalar//ToCanonical

g233a-TcsrAB//NoScalar//ToCanonical

g311a-TcsAuu//NoScalar//ToCanonical

g312a-TcsAur//NoScalar//ToCanonical

g313a-TcsAuB//NoScalar//ToCanonical

g322a-TcsArr

g323a-TcsArB//NoScalar//ToCanonical

g333a-TcsABF//NoScalar//ToCanonical

tcsuuA[-A]

gammauuA[-A]

tcsuuA[-F]+g[-A,-B]U[A]U[B]//PutScalar

U

Christofell tensor expressions and list

csuuurule=MakeRule[{gammauuu[],tcsuuu[]//PutScalar}];
csuurrule=MakeRule[{gammauur[],tcsuur[]//PutScalar}];
csuuArule=MakeRule[{gammauuA[-A],tcsuuA[-A]}];
csurrrule=MakeRule[{gammaurr[],tcsurr[]}];
csurArule=MakeRule[{gammaurA[-A],tcsurA[-A]}];
csuABrule=MakeRule[{gammauAB[-A,-B],tcsuAB[-A,-B]}];
csruurule=MakeRule[{gammaruu[],tcsruu[]}];
csrurrule=MakeRule[{gammarur[],tcsrur[]//PutScalar}];
csruArule=MakeRule[{gammaruA[-A],tcsruA[-A]}];
csrrrrule=MakeRule[{gammarrr[],tcsrrr[]}];
csrrArule=MakeRule[{gammarrA[-A],tcsrrA[-A]}];
csrABrule=MakeRule[{gammarAB[-A,-B],tcsrAB[-A,-B]}];
csAuurule=MakeRule[{gammaAuu[A],tcsAuu[A]}];
csAurrule=MakeRule[{gammaAur[A],tcsAur[A]}];
csAuBrule=MakeRule[{gammaAuB[A,-B],tcsAuB[A,-B]}];
csArrrule=MakeRule[{gammaArr[A],tcsArr[A]}];
csArBrule=MakeRule[{gammaArB[A,-B],tcsArB[A,-B]}];
csABFrule=MakeRule[{gammaABF[A,-B,-F],tcsABF[A,-B,-F]}];

csrules=Join[csuuurule,csuurrule,csuuArule,csurrrule,csurArule,csuABrule,csruurule,csrurrule,csruArule,csrrrrule,csrrArule,csrABrule,csAuurule,csAurrule,csAuBrule,csArrrule,csArBrule,csABFrule]

Riemann Tensor and Ricci (Don’t use)

riemann1[i1_,i2_,i3_,i4_,c1_,c2_,c3_,c4_]:=Module[{Z},Sum[metlist[i4,Z][[c4,r1]]der[i2,c2][cslist[Z,i1,i3][[r1,c1,c3]]],{r1,1,3}]];
riemann2[i1_,i2_,i3_,i4_,c1_,c2_,c3_,c4_]:=Module[{Z},-Sum[metlist[i4,Z][[c4,r1]]der[i1,c1][cslist[Z,i2,i3][[r1,c2,c3]]],{r1,1,3}]];
riemann3[i1_,i2_,i3_,i4_,c1_,c2_,c3_,c4_]:= Module[{Z1,Z2},Sum[metlist[i4,Z1][[c4,r1]] cslist[Z2,i1,i3][[r2,c1,c3]]cslist[Z1,i2,Z2][[r1,c2,r2]],{r1,1,3},{r2,1,3}]];
riemann4[i1_,i2_,i3_,i4_,c1_,c2_,c3_,c4_]:= -Module[{Z1,Z2},Sum[metlist[i4,Z1][[c4,r1]] cslist[Z2,i2,i3][[r2,c2,c3]]cslist[Z1,i1,Z2][[r1,c1,r2]],{r1,1,3},{r2,1,3}]];
riemann[i1_,i2_,i3_,i4_,c1_,c2_,c3_,c4_]:=riemann1[i1,i2,i3,i4,c1,c2,c3,c4] + riemann2[i1,i2,i3,i4,c1,c2,c3,c4] + riemann3[i1,i2,i3,i4,c1,c2,c3,c4] +riemann4[i1,i2,i3,i4,c1,c2,c3,c4]
Ricci Tensor
ricci[i1_,i2_,c1_,c2_]:=Module[{Z1,Z2},Sum[invmetlist[Z1,Z2][[r1,r2]]riemann[Z1,i1,Z2,i2,r1,c1,r2,c2],{r1,1,3},{r2,1,3}]];
cricci[i1_,i2_,c1_,c2_,s1_]:=Coefficient[Module[{Z1,Z2},Sum[invmetlist[Z1,Z2][[r1,r2]]riemann[Z1,i1,Z2,i2,r1,c1,r2,c2],{r1,1,3},{r2,1,3}]]//.bondirules//.csrules,r,-s1]

Ricci Directly from Christofell

rule1={g[F_,G_]pr[g[-F_,-G_]]->(4/r)};
upull={PD[a_][ParamD[u][expr_]]:> ParamD[u][PD[a][expr]],PD[-a_][ParamD[u][expr_]]:> ParamD[u][PD[-a][expr]]};
rpull={PD[a_][ParamD[r][expr_]]:> ParamD[r][PD[a][expr]],PD[-a_][ParamD[r][expr_]]:> ParamD[r][PD[-a][expr]]};

ricci1[i1_,i2_,c1_,c2_]:=Sum[ der[Z0,r1][cslist[Z0,i1,i2][[r1,c1,c2]]],{r1,1,3}]
ricci2[i1_,i2_,c1_,c2_]:=-Sum[ der[i1,c1][cslist[Z0,Z0,i2][[r1,r1,c2]]],{r1,1,3}]
ricci3[i1_,i2_,c1_,c2_]:= Sum[cslist[Z0,Z0,Z1][[r1,r1,r2]]cslist[Z1,i1,i2][[r2,c1,c2]],{r1,1,3},{r2,1,3}]
ricci4[i1_,i2_,c1_,c2_]:=-Sum[cslist[Z0,i1,Z1][[r1,c1,r2]]cslist[Z1,Z0,i2][[r2,r1,c2]],{r1,1,3},{r2,1,3}]
ricci[i1_,i2_,c1_,c2_]:=ricci1[i1,i2,c1,c2] + ricci2[i1,i2,c1,c2] +ricci3[i1,i2,c1,c2] +ricci4[i1,i2,c1,c2]

Ruu=(ricci[1,1,1,1]//.csrules//NoScalar)//.bondirules//ReplaceDummies//ToCanonical

Rur=ricci[1,2,1,2]//.csrules//NoScalar//.bondirules//ContractMetric//ReplaceDummies//ToCanonical

RuA=ricci[1,A,1,3]//.csrules//NoScalar//.bondirules//ContractMetric//ReplaceDummies//ToCanonical

Rrr=ricci[2,2,2,2]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical

RrA=ricci[2,A,2,3]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical

RAB=ricci[A,B,3,3]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical

Ricci of BT paper

The Ricci tensor in the Aspects of the BMS/CFT correspondence paper by G. Barnich and C. Troessaert

(Subscript[R, μ⋁])=[(∂_α)+(Subscript[(2β+(1/2)log[((|)^((2)))g|]), ,α])] (Subscript[(Γ^α), μν]) -(∂_μ)(∂_⋁)(2β+(1/2)log[((|)^((2)))g|]) -(Subscript[(Γ^α), νβ]) (Subscript[(Γ^β), μα])

The above formula can be rewritten by noticing that for the derivative of determinant a matrix we have (∂/(∂ x))Log[det[A]]=Tr[(A^(-1))(∂_x)A]

(Subscript[R, μ⋁])=[(∂_α)+(2(∂_α)β+(1/2)(g^AB)(∂_α)(Subscript[g, AB]))] (Subscript[(Γ^α), μν]) -(∂_μ)(2(∂_ν)β+(1/2)(g^AB)(∂_ν)(Subscript[g, AB])) -(Subscript[(Γ^α), νβ]) (Subscript[(Γ^β), μα])

(*DefTensor[χ[],{u,M2}];
ricci1[i1_,i2_,c1_,c2_]:=Sum[Sum[cslist[Z,i2,Z0][[r1,c2,r2]] cslist[Z0,i1,Z][[r2,c1,r1]],{r2,1,3}],{r1,1,3}];
riccibt[i1_,i2_,c1_,c2_]:=Sum[der[Z,r1][cslist[Z,i1,i2][[r1,c1,c2]]]+der[Z,r1][2β[]+(1/2)Log[(r^4)χ[]]]cslist[Z,i1,i2][[r1,c1,c2]],{r1,1,3}]-der[i1,c1][der[i2,c2][2β[]+(1/2)Log[(r^4)χ[]]]]-ricci1[i1,i2,c1,c2];

riccibt1[i1_,i2_,c1_,c2_]:=Sum[Sum[Module[{Z0,Z},cslist[Z,i2,Z0][[r1,c2,r2]] cslist[Z0,i1,Z][[r2,c1,r1]]],{r2,1,3}],{r1,1,3}];
riccibt[i1_,i2_,c1_,c2_]:=Sum[Module[{Z},der[Z,r1][cslist[Z,i1,i2][[r1,c1,c2]]]+(der[Z,r1][2β[]]+(1/2)Module[{Z1,Z2},g[Z1,Z2]der[Z,r1][g[-Z1,-Z2]]])cslist[Z,i1,i2][[r1,c1,c2]]],{r1,1,3}]-der[i1,c1][(2der[i2,c2][β[]]+(1/2)Module[{Z1,Z2},g[Z1,Z2]der[i2,c2][g[-Z1,-Z2]]])]-riccibt1[i1,i2,c1,c2];

Ruubt=(((((riccibt[1,1,1,1]//.csrules)//NoScalar)//.rpull)//.upull)//.rule1)//ContractMetric//ToCanonical//ReplaceDummies

Rurbt=(riccibt[1,2,1,2]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical)//.rule1

RuAbt=(riccibt[1,A,1,3]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical)//.rule1

Rrrbt=riccibt[2,2,2,2]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical

RrAbt=riccibt[2,A,2,3]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical

RABbt=riccibt[A,B,3,3]//.csrules//NoScalar//ContractMetric//ReplaceDummies//ToCanonical