The N.P. and G.H.P. formalisms.

An application of Spinors and xCoba.

Alfonso García-Parrado Gómez-Lobo
Universidade do Minho, Portugal
September 2009

In this notebook we derive all the equations of the Newman-Penrose formalism from scratch, by using spinor calculus. We use the equations obtained to introduce the essentials of the GHP formalism (GHP operators, weighted quantities, etc) and then we obtain the set of GHP equations. This notebook can be used as starting point for any computation involving the N.P. and G.H.P. formalisms.

For a quick start, execute sections 1, 2 and 3 and then proceed to section 4 where the essential explanations about how to use this notebook are provided.

1. Spin structure on the spacetime manifold

We start by loading  Spinors`.

<<xAct`Spinors`

Definition of a four dimensional  manifold M4:

DefManifold[M4,4,{a,b,c,d,f,p,q,r,m,l,h,j,n,t,s}]

Definition of a Lorentzian metric on the manifold M4:

DefMetric[{1,3,0},g[-a,-b],CD]

We define a spin structure comprising the complex vector bundle Spin whose abstract indices are {A, B, C, D, F, H, L, P, Q}. We need to supply as arguments the name of the metric tensor of the background Lorentzian manifold g[-a,-b], the name of the antisymmetric spin metric ϵ[-A,-B], the name of the soldering form σ[a,-A,-A†] and the name of the spin covariant derivative CDe[-a].The option SpinorPrefix is used to introduce a tag which will be  prepended automatically to  any spinor related to a spacetime tensor and the option SpinorMark introduces a formatting of the tag SP different to the default one. The long output of DefSpinStructure can be suppressed  by adding the option Info->False which deactivates the information of the definition commands .

DefSpinStructure[g,Spin,{A,B,C,D,F,H,L,P,Q},ϵ,σ,CDe,SpinorPrefix->SP,SpinorMark->"S",Info->False]

Pretty printing options for the spinor indices and the spin metric.

{PrintAs[A†]^="A'",PrintAs[B†]^="B'",PrintAs[C†]^="C'",PrintAs[D†]^="D'",PrintAs[F†]^="F'",PrintAs[H†]^="H'",PrintAs[L†]^="L'",PrintAs[M†]^="M'",PrintAs[P†]^="P'",PrintAs[Q†]^="Q'",PrintAs[ϵ†]^="(Overscript[ϵ, __])"};

2. The Newman-Penrose formalism

The Newman-Penrose formalism can be regarded as an application of the spinor calculus. In this section we show how all the equations of this formalism can be derived sytematically and efficiently using Spinors`  in conjuntion with the package xCoba`. Full explanations about the usage of xCoba`  can be found in the package documentation.

We load xCoba`.

<<xAct`xCoba`

We turn off the verbose messages issued by ComponentValue.

$CVVerbose=False;

In the following subsections we introduce the spin dyad and its associated null tetrad. We will use  xCoba` to introduce two frames (basis), called Dyad and NP and we shall create a parallel set of vectors for the elements in each basis. See the corresponding subsections for full details.

Spin dyad

First of all, we define the elements of a spin dyad.

DefSpinor[#,M4]&/@{o[A],ι[A]};
PrintAs[o†]^="(Overscript[o, __])";
PrintAs[ι†]^="(Overscript[ι, __])";

These spinors belong to a spin basis which we define next.

DefBasis[Dyad,Spin,{0,1},BasisColor->RGBColor[1,0,0],Dagger->Complex]

Component indices in the conjugated basis will be also primed :

Dyad†/:CIndexForm[i_Integer,Dyad†]:=StringJoin[ToString[i],"'"];

By definition, these are the equations relating both sets of objects:

eqs={o[A]==Basis[{0,-Dyad},A],ι[A]==Basis[{1,-Dyad},A]}

From them, we read and store the components of the spinors (Subscript[o,  ]^A), (Subscript[ι,  ]^A) .

Map[ToBasis[Dyad],eqs,{2}]

We now do the same for the conjugated equations:

Map[ToBasis[Dyad†],Dagger[eqs],{2}]

ComponentArray@Join[%%,%]

%/.Equal->ComponentValue;

Since {(Subscript[o,  ]^A),(Subscript[ι,  ]^A)} is a spin dyad, the spin metric can be written in the form

eqs={ϵ[A,B]==o[A] ι[B]-o[B] ι[A]}

The components of the spin metric and its complex conjugate can now be computed and stored.

Map[ToBasis[Dyad],eqs,{2}]

Map[ToBasis[Dyad†],Dagger[eqs],{2}]

ToValues@ComponentArray@Join[%%,%]

%/.Equal->ComponentValue;

We deduce from here the components of (Subscript[ϵ, AB]^(  )) by means of the relation (Subscript[ϵ, AB]^(  )) (Subscript[ϵ,   ]^CB)=(Subscript[δ, A ]^( C)).  To that end we need to find the inverse of the transposed of the matrix representation of the components of (Subscript[ϵ,   ]^AB).

EP=ToValues@TableOfComponents[ϵ[A,B],Dyad]

Inverse@Transpose@EP

Storage of the components of  (Subscript[ϵ,   ]^AB) and its complex conjugate.

MetricInBasis[ϵ,-Dyad,%];
MetricInBasis[ϵ†,-Dyad†,%%];

We now compute and store the components of (Subscript[o, A]^( )), (Subscript[ι, A]^( )) and their complex conjugate.

eqs={o[-A]==ϵ[-B,-A] o[B],ι[-A]==ϵ[-B,-A] ι[B]}

Map[ToBasis[Dyad],eqs,{2}]

Map[ToBasis[Dyad†],Dagger[eqs],{2}]

Map[TraceBasisDummy,Join[%%,%],{2}]

ToValues@ComponentArray@%

%/.Equal->ComponentValue;

We change the Rule assignment to the Set assignment in each FoldedRule storing the components computed so far

RuleToSet/@{ϵ,ϵ†,o,o†,ι,ι†};

Null tetrad

We define now four vectors which will represent the null tetrad basis elements.

DefTensor[lNP[a],M4,PrintAs->"l"]

DefTensor[nNP[a],M4,PrintAs->"n"]

DefTensor[mNP[a],M4,Dagger->Complex,PrintAs->"m"]

PrintAs@mNP†^="(OverBar[m])";

These vectors belong to a basis (null  tetrad) which we define next.

DefBasis[NP,TangentM4,{1,2,3,4},BasisColor->RGBColor[0,0,1]]

We specify the behaviour of the elements of this basis under complex conjugation. This is achieved with the command SetDaggerMatrix.

SetDaggerMatrix[NP,{{1,0,0,0},{0,1,0,0},{0,0,0,1},{0,0,1,0}}]

We format a number of objects according to standard conventions. Due to the new way of sorting definitions in Mathematica  6.0, we need to stop the formatting engine and start it again after defining these new rules.

Stop formatting engine.

xTensorFormStop[];

Formatting of the directional derivatives with the standard NP symbols.

FormatBasis[PDNP[{1,-NP}],"D"];
FormatBasis[PDNP[{2,-NP}],"Δ"];
FormatBasis[PDNP[{3,-NP}],"δ"];
FormatBasis[PDNP[{4,-NP}],"(OverBar[δ])"];

The Newman-Penrose directional derivatives can also act on spinors. For that case we need to use the covariant derivative CDe rather than PDNP.  Therefore we need to set a formatting for the directional derivatives taken with respect to CDe (note that when CDe and PDNP act on scalars or tensors they coincide).

FormatBasis[CDe[{1,-NP}],"D"];
FormatBasis[CDe[{2,-NP}],"Δ"];
FormatBasis[CDe[{3,-NP}],"δ"];
FormatBasis[CDe[{4,-NP}],"(OverBar[δ])"];

Restart formatting  engine:

xTensorFormStart[];

These are the relations between the elements of the null tetrad  and the elements of the basis NP.

{lNP[a]==Basis[a,{1,-NP}],nNP[a]==Basis[a,{2,-NP}],mNP[a]==Basis[a,{3,-NP}],mNP†[a]==Basis[a,{4,-NP}]}

From this relation we compute the components of (Subscript[l,  ]^a),  (Subscript[n,  ]^a),  (Subscript[m,  ]^a),  (Subscript[(OverBar[m]),  ]^a) in the basis NP .

Map[ToBasis[NP],%,{2}]

Flatten@ComponentArray@%

%/.Equal->ComponentValue;

As is well known, in the null tetrad the metric takes the form

g[a,b]==lNP[a]nNP[b]+lNP[b]nNP[a]-(mNP[a]mNP†[b]+mNP[b]mNP†[a])

We compute and store the components of (Subscript[g,   ]^ab) in the basis NP.

ToBasis[NP]/@%

ToValues@ComponentArray@%

We store the components of the metric tensor

%/.Equal->ComponentValue

We compute the components of (Subscript[g, ab]^(  ))  and store their values.

MatrixForm@ToValues@TableOfComponents[g[a,b],NP]

MatrixForm@Inverse@%

MetricInBasis[g,-NP,%]

Finally we change the Rule assignment to the Set assignment in the FoldedRule storing all the components of the metric tensor.

RuleToSet@g

We also need the components for the elements of the null tetrad with the indices downstairs. They are computed from those with the indices upstairs.

{lNP[-a]==g[-a,-b]lNP[b],nNP[-a]==g[-a,-b]nNP[b],mNP[-a]==g[-a,-b]mNP[b],mNP†[-a]==g[-a,-b]mNP†[b]}

Map[ToBasis[NP],%,{2}]

Map[TraceBasisDummy,%,{2}]

ToValues@Flatten@ComponentArray@%

%/.Equal->ComponentValue;

Automatic replacement of the values of the components of the elements of the null tetrad.

RuleToSet/@{lNP,nNP,mNP,mNP†};

It is convenient to have a rule which relates  (Subscript[l,  ]^a),  (Subscript[n,  ]^a),  (Subscript[m,  ]^a),  (Subscript[(OverBar[m]),  ]^a) and the elements of the basis NP. We compute such a rule next.

{lNP[a]==SeparateBasis[NP]@lNP[a],nNP[a]==SeparateBasis[NP]@nNP[a],mNP[a]==SeparateBasis[NP]@mNP[a],mNP†[a]==SeparateBasis[NP]@mNP†[a]}

Map[TraceBasisDummy,%,{2}]

Solve[%,Cases[%,Basis[{__},a_],Infinity]]//Flatten

%/.HoldPattern@Rule[X_,Y_]:>MakeRule[{X,Y}]//Flatten//Union

BasisToVectors=%;

We need the same rule with the indices downstairs.

{lNP[-a]==SeparateBasis[NP]@lNP[-a],nNP[-a]==SeparateBasis[NP]@nNP[-a],mNP[-a]==SeparateBasis[NP]@mNP[-a],mNP†[-a]==SeparateBasis[NP]@mNP†[-a]}

Map[TraceBasisDummy,%,{2}]

Solve[%,Cases[%,Basis[__],Infinity]]//Flatten

%/.HoldPattern@Rule[X_,Y_]:>MakeRule[{X,Y}]//Flatten//Union

We combine these relations with the relations found above for the indices upstairs.

AppendTo[BasisToVectors,%]

Relation between the spin dyad and the null tetrad

The relation between the elements of the spinor dyad and the elements of the null tetrad is as follows

SpinDyadToNullTetrad={σ[a,-A,-A†]o[A]Dagger@o[A]==lNP[a],σ[a,-A,-A†]ι[A]Dagger@ι[A]==nNP[a],σ[a,-A,-A†]o[A]Dagger@ι[A]==mNP[a],σ[a,-A,-A†]Dagger[o[A]Dagger@ι[A]]==mNP†[a]}

Using this relation we find and store the components of the soldering form (Subscript[σ,  AA']^(a   )).

Map[ToBasis[Dyad],%,{2}]

Map[ToBasis[Dyad†],%,{2}]

Map[ToBasis[NP],%,{2}]

Map[TraceBasisDummy,%,{2}]

ComponentArray@%

%/.Equal->ComponentValue

We also need the components of the soldering form with the spacetime index downstairs and the spin indices upstairs.

NullTetradToSpinDyad=Map[PutSolderingForm,SpinDyadToNullTetrad,{2}]/.B->A/.B†->A†

Map[ToBasis[Dyad],%,{2}]

Map[ToBasis[Dyad†],%,{2}]

Map[ToBasis[NP],%,{2}]

Map[TraceBasisDummy,%,{2}]

Flatten@ComponentArray@%

Solve[%,Cases[%,_σ,Infinity]]

We store these values.

%/.Rule->ComponentValue

Change of the Rule assignment to the Set assignment in the folded rule.

RuleToSet@σ

Newman-Penrose spin coefficients

We define the 12 Newmann-Penrose spin coefficients, and their complex conjugates:

DefSpinor[κDyad[],M4];
PrintAs[κDyad]^="κ";
PrintAs[κDyad†]^="(OverBar[κ])";

DefSpinor[ϵDyad[],M4];
PrintAs[ϵDyad]^="ϵ";
PrintAs[ϵDyad†]^="(OverBar[ϵ])";

DefSpinor[πDyad[],M4];
PrintAs[πDyad]^="π";
PrintAs[πDyad†]^="(OverBar[π])";

DefSpinor[τDyad[],M4];
PrintAs[τDyad]^="τ";
PrintAs[τDyad†]^="(OverBar[τ])";

DefSpinor[γDyad[],M4];
PrintAs[γDyad]^="γ";
PrintAs[γDyad†]^="(OverBar[γ])";

DefSpinor[νDyad[],M4];
PrintAs[νDyad]^="ν";
PrintAs[νDyad†]^="(OverBar[ν])";

DefSpinor[σDyad[],M4];
PrintAs[σDyad]^="σ";
PrintAs[σDyad†]^="(OverBar[σ])";

DefSpinor[βDyad[],M4];
PrintAs[βDyad]^="β";
PrintAs[βDyad†]^="(OverBar[β])";

DefSpinor[μDyad[],M4];
PrintAs[μDyad]^="μ";
PrintAs[μDyad†]^="(OverBar[μ])";

DefSpinor[ρDyad[],M4];
PrintAs[ρDyad]^="ρ";
PrintAs[ρDyad†]^="(OverBar[ρ])";

DefSpinor[αDyad[],M4];
PrintAs[αDyad]^="α";
PrintAs[αDyad†]^="(OverBar[α])";

DefSpinor[λDyad[],M4];
PrintAs[λDyad]^="λ";
PrintAs[λDyad†]^="(OverBar[λ])";

This is full the list of Newman-Penrose spin coefficients.

NPSpinCoefficients={αDyad[],βDyad[],γDyad[],ϵDyad[],κDyad[],λDyad[],μDyad[],νDyad[],πDyad[],ρDyad[],σDyad[],τDyad[]}

%//Length

The spin coefficients are defined through the derivations of the elements of the spin tetrad by means of the following relations.

DyadDerivatives={
CDe[{1,-NP}][o[-A]]==  o[-A]ϵDyad[]-ι[-A]κDyad[],CDe[{1,-NP}][ι[-A]]==-ι[-A]ϵDyad[]+o[-A]πDyad[],CDe[{2,-NP}][o[-A]]==  o[-A]γDyad[]-ι[-A]τDyad[],CDe[{2,-NP}][ι[-A]]==-ι[-A]γDyad[]+o[-A]νDyad[],CDe[{3,-NP}][o[-A]]==  o[-A]βDyad[]-ι[-A]σDyad[],CDe[{3,-NP}][ι[-A]]==-ι[-A]βDyad[]+o[-A]μDyad[],CDe[{4,-NP}][o[-A]]==  o[-A]αDyad[]-ι[-A]ρDyad[],CDe[{4,-NP}][ι[-A]]==-ι[-A]αDyad[]+o[-A]λDyad[]
}

From this expression we compute and store the components of the spin covariant derivative "intrinsic" connection (these are the components of the "inner" Christoffel symbols of the covariant derivative CDe).

Map[ToBasis[Dyad],%,{2}]

Map[ToBasis[Dyad],%,{2}]

Map[TraceBasisDummy,%,{2}]

Flatten@ComponentArray@%

Solve[%,Cases[%,_AChristoffelCDePDDyad,Infinity]]//Flatten

%/.Rule->ComponentValue

We need the complex conjugate of all these relations.

Map[Dagger,%,{2}]

%/.Rule->ComponentValue

Automatic replacement of the components of  (Subscript[A[▽,𝒟],  bC]^(A  )) and (Subscript[A[▽,𝒟]†,   bC']^(A'   )).

RuleToSet@AChristoffelCDePDDyad;

RuleToSet@AChristoffelCDePDDyad†;

Components of the Levi-Civita connection in the null tetrad

We need to obtain the components of the Levi-Civita connection (Ricci rotation coefficients) in the null tetrad. This is done by taking the covariant derivative of the set of equations relating the null tetrad elements and the spin dyad elements and using the expressions for the derivatives of the latter in terms of the Newman-Penrose spin coefficients.

As we know the relation between the spinor dyad and the null tetrad is

SpinDyadToNullTetrad

We take now the derivative of each of these equations and expand them in components.

Map[CDe[-b],%,{2}]

Map[ToBasis[NP],%,{2}]

Map[ToBasis[NP],%,{2}]

Map[ToBasis[Dyad],%,{2}]

Map[ToBasis[Dyad†],%,{2}]

All the ocurrences of the spin covariant derivative are now acting on scalar functions. Therefore we may replace them by any other covariant derivative, in particular PDNP.

%/.CDe->PDNP

Map[TraceBasisDummy,%,{2}];

Flatten@ComponentArray@%

Solve[%,Union@Cases[%,_ChristoffelCDePDNP,Infinity]]//Flatten//Simplify

These are the components of the Levi-Civita connection in the null tetrad written in terms of the spin coefficients. We store them.

%/.Rule->ComponentValue;

We show the list of Ricci rotation coefficients.

TensorValues@ChristoffelCDePDNP

From now on, each Ricci rotation coefficient will be automatically replaced by its value in terms of the Newman-Penrose spin coefficients.

RuleToSet@ChristoffelCDePDNP;

Commutation relations

In this subsection we calculate the commutation coefficients of the elements of the null tetrad in terms of the spin coefficients. This is achieved by calculating the brackets of the elements of the null tetrad which in turn requires the commutation coefficients of the null tetrad elements. These coeffients are the components of the tensor TorsionPDNP.

The first step is the creation of a folded rule containing the independent components of TorsionPDNP in the null tetrad.

AllComponentValues@ToBasis[NP]@TorsionPDNP[a,-b,-c]

Next we compute the explicit expression for the bracket of each pair of elements of the null tetrad.

Bracket[Basis[{-c,-NP},a],Basis[{-d,-NP},a]][b]==ChangeTorsion[Bracket[Basis[{-c,-NP},a],Basis[{-d,-NP},a]][b],PDNP,CDe]

ToBasis[NP]/@%

Finally we compute and store the components of  TorsionPDNP in the null tetrad.

Flatten@ComponentArray@%

Union@ToValues@%

Solve[%,Union@Cases[%,_TorsionPDNP,Infinity]]//Flatten

We store these values.

%/.Rule->ComponentValue;

RuleToSet@TorsionPDNP;

We can now write down the equations arising from the commutation relations. First we define a scalar function upon which the differential operators will act.

DefTensor[ψ[],M4]

By default, xTensor`  commutes automatically pairs of covariant derivatives when they act on scalars.

PDNP[-a]@PDNP[-b]@ψ[]

We need to remove this automatic commutation in our calculations.  This is done by setting the global variable $CommuteCovDsOnScalars to False.

$CommuteCovDsOnScalars=False;

Commutation of the operator PDNP on the scalar ψ.

PDNP[-a]@PDNP[-b]@ψ[]-PDNP[-b]@PDNP[-a]@ψ[]==SortCovDs[PDNP[-a]@PDNP[-b]@ψ[]-PDNP[-b]@PDNP[-a]@ψ[]]

The components of this relation in the null tetrad yield the Newman-Penrose commutation relations.

ToBasis[NP]/@%

ToBasis[NP]/@%

TraceBasisDummy/@%

Union@Flatten@ComponentArray@%

We extract the independent equations from this set.

Solve[%,Union@Cases[%,PDNP[_]@PDNP[_]@ψ[],Infinity]]//Flatten

These equations come in complex-conjugate pairs.  Therefore we only need to consider a subset of them.

Expand//@%;

Union[%,SameTest->(Dagger/@#1===#2&)];

FullSimplify//@%

Therefore, the full set of independent commutation relations is

NPCommutators=%/.Rule->Equal

Components of the Riemann tensor in terms of the components of the curvature spinors

We are going to write the components of the Riemann tensor in the null tetrad in terms of the spinor curvature components expressed in the spin dyad.  First we compute folded rules containing the independent components of each of the quantities involved.

AllComponentValues@ToBasis[Dyad]@PsiCDe[-A,-B,-C,-D]

RuleToSet@PsiCDe

AllComponentValues@ToBasis[Dyad†]@PsiCDe†[-A†,-B†,-C†,-D†]

RuleToSet@PsiCDe†

AllComponentValues@ToBasis[Dyad†]@ToBasis[Dyad]@PhiCDe[-A,-B,-A†,-B†]

RuleToSet@PhiCDe

We introduce the scalars which will represent the components of the Weyl spinor

DefTensor[#,M4,Dagger->Complex]&/@{PsiCDe0Dyad[],PsiCDe1Dyad[],PsiCDe2Dyad[],PsiCDe3Dyad[],PsiCDe4Dyad[]};

The different components of the Weyl spinor are formatted with their conventional names.

PrintAs@PsiCDe0Dyad^="(Subscript[Ψ, 0])";
PrintAs@PsiCDe1Dyad^="(Subscript[Ψ, 1])";
PrintAs@PsiCDe2Dyad^="(Subscript[Ψ, 2])";
PrintAs@PsiCDe3Dyad^="(Subscript[Ψ, 3])";
PrintAs@PsiCDe4Dyad^="(Subscript[Ψ, 4])";
PrintAs@PsiCDe0Dyad†^="(Subscript[(OverBar[Ψ]), 0])";
PrintAs@PsiCDe1Dyad†^="(Subscript[(OverBar[Ψ]), 1])";
PrintAs@PsiCDe2Dyad†^="(Subscript[(OverBar[Ψ]), 2])";
PrintAs@PsiCDe3Dyad†^="(Subscript[(OverBar[Ψ]), 3])";
PrintAs@PsiCDe4Dyad†^="(Subscript[(OverBar[Ψ]), 4])";

SetToRule@PsiCDe

SetToRule@PsiCDe†

Explicit definition of the components of the Weyl spinor.

{PsiCDe[{0,-Dyad},{0,-Dyad},{0,-Dyad},{0,-Dyad}]->PsiCDe0Dyad[],PsiCDe[{0,-Dyad},{0,-Dyad},{0,-Dyad},{1,-Dyad}]->PsiCDe1Dyad[],PsiCDe[{0,-Dyad},{0,-Dyad},{1,-Dyad},{1,-Dyad}]->PsiCDe2Dyad[],PsiCDe[{0,-Dyad},{1,-Dyad},{1,-Dyad},{1,-Dyad}]->PsiCDe3Dyad[],PsiCDe[{1,-Dyad},{1,-Dyad},{1,-Dyad},{1,-Dyad}]->PsiCDe4Dyad[]}

%/.Rule->ComponentValue

Map[Dagger,%,{2}]

%/.Rule->ComponentValue

RuleToSet@PsiCDe

RuleToSet@PsiCDe†

We introduce the scalars which will represent the components of the Ricci spinor.

DefTensor[#,M4,Dagger->Complex]&/@{PhiCDe00Dyad[],PhiCDe01Dyad[],PhiCDe02Dyad[],PhiCDe10Dyad[],PhiCDe11Dyad[],PhiCDe12Dyad[],PhiCDe20Dyad[],PhiCDe21Dyad[],PhiCDe22Dyad[]};

The components of the Ricci spinor are formatted with their conventional names.

PrintAs[PhiCDe00Dyad]^="(Subscript[Φ, 00])";
PrintAs[PhiCDe01Dyad]^="(Subscript[Φ, 01])";
PrintAs[PhiCDe02Dyad]^="(Subscript[Φ, 02])";
PrintAs[PhiCDe10Dyad]^="(Subscript[Φ, 10])";
PrintAs[PhiCDe11Dyad]^="(Subscript[Φ, 11])";
PrintAs[PhiCDe12Dyad]^="(Subscript[Φ, 12])";
PrintAs[PhiCDe20Dyad]^="(Subscript[Φ, 20])";
PrintAs[PhiCDe21Dyad]^="(Subscript[Φ, 21])";
PrintAs[PhiCDe22Dyad]^="(Subscript[Φ, 22])";

SetToRule@PhiCDe

Explicit definition of the components of the Ricci spinor.

{PhiCDe[{0,-Dyad},{0,-Dyad},{0,-Dyad†},{0,-Dyad†}]->PhiCDe00Dyad[],PhiCDe[{0,-Dyad},{0,-Dyad},{0,-Dyad†},{1,-Dyad†}]->PhiCDe01Dyad[],PhiCDe[{0,-Dyad},{0,-Dyad},{1,-Dyad†},{1,-Dyad†}]->PhiCDe02Dyad[],PhiCDe[{0,-Dyad},{1,-Dyad},{0,-Dyad†},{0,-Dyad†}]->PhiCDe10Dyad[],PhiCDe[{1,-Dyad},{1,-Dyad},{0,-Dyad†},{0,-Dyad†}]->PhiCDe20Dyad[],PhiCDe[{0,-Dyad},{1,-Dyad},{0,-Dyad†},{1,-Dyad†}]->PhiCDe11Dyad[],PhiCDe[{1,-Dyad},{1,-Dyad},{0,-Dyad†},{1,-Dyad†}]->PhiCDe21Dyad[],PhiCDe[{0,-Dyad},{1,-Dyad},{1,-Dyad†},{1,-Dyad†}]->PhiCDe12Dyad[],PhiCDe[{1,-Dyad},{1,-Dyad},{1,-Dyad†},{1,-Dyad†}]->PhiCDe22Dyad[]}

%/.Rule->ComponentValue;

ToValues@Map[Dagger,%,{2}]

%/.Rule->Equal

Solve[%,{PhiCDe00Dyad†[],PhiCDe01Dyad†[],PhiCDe02Dyad†[],PhiCDe10Dyad†[],PhiCDe11Dyad†[],PhiCDe12Dyad†[],PhiCDe20Dyad†[],PhiCDe21Dyad†[],PhiCDe22Dyad†[]}]//Flatten

%/.Rule->Set;

RuleToSet@PhiCDe

PrintAs[LambdaCDe]^="Λ";

Computation of the folded rule for the Riemann tensor.

AllComponentValues@ToBasis[NP]@RiemannCD[-a,-b,-c,-d];

RuleToSet@RiemannCD

Next we show how to write Riemann tensor components in terms of the components of curvature spinors

RiemannCD[-a,-b,-c,-d]

%==Expand@Decomposition[SeparateSolderingForm[][%],Riemann]

ToBasis[Dyad†]/@ToBasis[Dyad]/@ToBasis[NP]/@%

TraceBasisDummy/@%;

Flatten@ComponentArray@%;

Union@%

Solve[%,Union@Cases[%,_RiemannCD,Infinity]]//Flatten

We add the values just found to the folded rule containg the components of the Riemann tensor.

SetToRule@RiemannCD

%%/.Rule->ComponentValue;

RuleToSet@RiemannCD

From previous computations we can obtain and store the values for the components of the Ricci tensor.

AllComponentValues@ToBasis[NP]@RicciCD[-a,-b];

RicciCD[-a,-b]==g[p,q]RiemannCD[-a,-p,-b,-q]

ToBasis[NP]/@%

TraceBasisDummy/@%

Flatten@ComponentArray@%

Union@%

%/.Equal->ComponentValue;

RuleToSet@RicciCD

The scalar curvature is worked out in a similar fashion.

RicciScalarCD[]==ToBasis[NP]@g[a,b]RicciCD[-a,-b]

ToBasis[NP]/@%

TraceBasisDummy/@%//Expand

%/.Equal->ComponentValue

RuleToSet@RicciScalarCD

We may also need the components of the traceless part of the Ricci tensor.

AllComponentValues@ToBasis[NP]@TFRicciCD[-a,-b];

TFRicciCD[-a,-b]==(TFRicciCD[-a,-b]//TFRicciToRicci)

ToBasis[NP]/@%

ToValues@Flatten@ComponentArray@%

Union@%

%/.Equal->ComponentValue

RuleToSet@TFRicciCD

This is the complete list of the components of the Riemann tensor.

NPCVComponents={PsiCDe0Dyad[],PsiCDe1Dyad[],PsiCDe2Dyad[],PsiCDe3Dyad[],PsiCDe4Dyad[],PhiCDe00Dyad[],PhiCDe01Dyad[],PhiCDe02Dyad[],PhiCDe10Dyad[],PhiCDe11Dyad[],PhiCDe12Dyad[],PhiCDe20Dyad[],PhiCDe21Dyad[],PhiCDe22Dyad[],LambdaCDe[]}

The Newman-Penrose equations

We now calculate the Riemann tensor with respect to the null tetrad

RiemannCD[-a,-b,-c,-d]==ChangeCurvature[RiemannCD[-a,-b,-c,-d],CD,PDNP]

%/.ChristoffelCDPDNP->ChristoffelCDePDNP

ToBasis[NP]/@%

ToBasis[NP]/@%

TraceBasisDummy/@%;

Flatten@ComponentArray@%;

From here we obtain directly the Newman-Penrose equations

Union[Simplify//@Union[%]];

NPRicci=%

Not all the equations in this bunch are independent. To extract the independent set of equations we just eliminate a certain set of variables. The variables which we are going to eliminate are

Dagger/@Flatten@Outer[PDNP[#1]@#2&,{{1,-NP},{2,-NP},{3,-NP},{4,-NP}},NPSpinCoefficients,1]

Eliminate[NPRicci,%]//Simplify;

List@@%;

Solve[%,Union@Cases[%,PDNP[_]@_,Infinity]]//Flatten//Simplify

NPRicci=(%/.Rule->Equal);

Map[FullSimplify,NPRicci,{2}]

We may need the complex conjugate set in future computations.

NPRicci†=Map[Dagger,NPRicci,{2}]

Bianchi identities

We take next the components of the second Bianchi identity in the null tetrad.

3*Antisymmetrize[CD[-a]@RiemannCD[-b,-c,-d,-f],{-a,-b,-c}]==0

ToCanonical/@%

ChangeCovD[#,CD,PDNP]&/@%

ToCanonical/@%

%/.ChristoffelCDPDNP->ChristoffelCDePDNP

ToBasis[NP]/@ToBasis[NP]/@%

TraceBasisDummy/@%;

Flatten@ComponentArray@%;

NPBianchi=Union[Simplify//@%];

Not all the equations here are independent.

Dagger/@Flatten@Outer[PDNP[#1]@#2&,{{1,-NP},{2,-NP},{3,-NP},{4,-NP}},NPCVComponents[[Range[1,5]]],1]

Join[%,{PDNP[{4,-NP}]@LambdaCDe[]}]

List@@Eliminate[NPBianchi,%];

The final result for the Bianchi identities is

NPBianchi=Map[FullSimplify,%,{2}]

3. The GHP formalism

The Geroch-Held-Penrose formalism (known as GHP formalism) is a particularisation of the Newman-Penrose formalism in which the spin coefficients are separated according to their boost and spin weight. Also the direcctional derivatives associated to the null tetrad are replaced by differential operators which behave well under boost and spin transformations and therefore we can speak of the boost and spin weight of these operators. This enables us to re-write the basic equations used in the Newman-Penrose formalism in terms of boost-weighted quantities only. In this section we show how this is accomplished in the framework of Spinors` and xCoba` .

Boost and spin weights

The GHP formalism only admits weighted quantities. In this subsection we introduce a command, called GHPWeightOf, which computes the boost and spin weight of any quantity. These are integers which are kept in a list.  The command GHPWeightOf also checks that the GHP weight of the terms of any sum all agree, throwing an error otherwise.

GHPWeightOf::usage="GHPWeightOf[expr] returns the GHP boost and spin weight of any expression. If the expression is not weighted, then an error message is returned";

Weights of integers, rationals and complex numbers.

GHPWeightOf[num_?IntegerQ ]:={0,0};
GHPWeightOf[_Rational]:={0,0};
GHPWeightOf[_Complex]:={0,0};

Weights of products.

GHPWeightOf[expr_Times]:=Apply[Plus,GHPWeightOf/@Level[expr,{1}]];

Weights of sums

GHPWeightOf@expr_Plus:=If[Length@Union[GHPWeightOf/@Level[expr,1]]>1,Throw@Message[GHPWeightOf::Error],First@Union[GHPWeightOf/@Level[expr,1]]];
GHPWeightOf::Error="Inconsistent weights on Plus expression";

Weights of powers

GHPWeightOf[expr_^(n_?IntegerQ)]:=n GHPWeightOf@expr;

Weights of the spin coefficients

Some of the spin coefficients are weighted quantities. These are in the following list.

GHPSpinCoefficients=NPSpinCoefficients[[#]]&/@Range[5,12]

These are the  spin and boost weights of these quantities :

{GHPWeightOf@κDyad[]^={3,1},GHPWeightOf@λDyad[]^={-3,1},GHPWeightOf@μDyad[]^={-1,-1},GHPWeightOf@νDyad[]^={-3,-1},GHPWeightOf@πDyad[]^={-1,1},GHPWeightOf@ρDyad[]^={1,1},GHPWeightOf@σDyad[]^={3,-1},GHPWeightOf@τDyad[]^={1,-1}};

From here we compute the weights of the complex conjugate of these quantities

Dagger/@GHPSpinCoefficients

UpSet[GHPWeightOf@#,Reverse@GHPWeightOf@Dagger@#]&/@%

Weights of the components of the curvature spinors

It is easy to deduce the weights of the components of the curvature spinors. These are their values.

{GHPWeightOf@PsiCDe0Dyad[]^={4,0},GHPWeightOf@PsiCDe1Dyad[]^={2,0},GHPWeightOf@PsiCDe2Dyad[]^={0,0},GHPWeightOf@PsiCDe3Dyad[]^={-2,0},GHPWeightOf@PsiCDe4Dyad[]^={-4,0}};

{GHPWeightOf@PsiCDe0Dyad†[]^=Reverse@{4,0},GHPWeightOf@PsiCDe1Dyad†[]^=Reverse@{2,0},GHPWeightOf@PsiCDe2Dyad†[]^=Reverse@{0,0},GHPWeightOf@PsiCDe3Dyad†[]^=Reverse@{-2,0},GHPWeightOf@PsiCDe4Dyad†[]^=Reverse@{-4,0}};

{GHPWeightOf@PhiCDe00Dyad[]^={2,2},GHPWeightOf@PhiCDe10Dyad[]^={0,2},GHPWeightOf@PhiCDe01Dyad[]^={2,0},GHPWeightOf@PhiCDe11Dyad[]^={0,0},GHPWeightOf@PhiCDe20Dyad[]^={-2,2},GHPWeightOf@PhiCDe21Dyad[]^={-2,0},GHPWeightOf@PhiCDe02Dyad[]^={2,-2},GHPWeightOf@PhiCDe12Dyad[]^={0,-2},GHPWeightOf@PhiCDe22Dyad[]^={-2,-2}};

GHPWeightOf@LambdaCDe[]^={0,0};

GHP differential operators

The GHP differential operators are constructed by adding some extra terms to the four NP direccional derivatives. The result is a set of four differential operators having good transformation properties under spin and boost.

The GHP differential operators can be regarded as the "components" of a certain differential operator which we define next.  This  operator is not a true covariant derivative but just a differential operator acting on scalars,  so we need to use some primitive xAct` instructions in order to create it. We use the notation (Subscript[Θ, a]) as a representation for it.

CovDQ[Θ]^=True;
xAct`xTensor`Private`MakeLinearDerivative[{Θ[A_],Θ[A]},True];
SymmetryGroupOfCovD[Θ]^=StrongGenSet[{},GenSet[]];
ManifoldOfCovD[Θ]^=ManifoldOfCovD[CDe];
VBundlesOfCovD[Θ]^={};
Dagger[Θ[A_][expr_]]^:=Θ[DaggerIndex[A]][Dagger[expr]];
SymbolOfCovD[Θ]^={"Θ"};

Formatting of the GHP operators with their standard symbols.

xTensorFormStop[CovD]
FormatBasis[Θ[{1,-NP}],"þ"];
FormatBasis[Θ[{2,-NP}],"þ'"];
FormatBasis[Θ[{3,-NP}],"ð"];
FormatBasis[Θ[{4,-NP}],"ð'"];
xTensorFormStart[CovD]

The following constants represent respectively generic boost and spin weights.

DefConstantSymbol[w]

DefConstantSymbol[z]

We introduce a complex scalar of weight (p,q).

DefSpinor[η[LI@{p,q}],M4]

We specify the weight of the scalar quantity (Subscript[η,  ]^({w, z})) (note that the integers w and z are zero weighted).

GHPWeightOf@η[LI@{w,z}]^={w,z};
GHPWeightOf@w^={0,0};GHPWeightOf@z^={0,0};

The action of the differential operator (Subscript[Θ, a]) on a weighted scalar  (Subscript[η,  ]^({w, z})) is, by definition

{Θ[{1, -NP}][η[LI[{w, z}]]] ->(-(w*ϵDyad[]) - z*ϵDyad†[])*η[LI[{w, z}]]+ PDNP[{1, -NP}][η[LI[{w, z}]]], 
 Θ[{2, -NP}][η[LI[{w, z}]]] ->(-(w*γDyad[])- z*γDyad†[])*η[LI[{w, z}]]+PDNP[{2, -NP}][η[LI[{w, z}]]], 
 Θ[{3, -NP}][η[LI[{w, z}]]] ->(-(z*αDyad†[])-w*βDyad[])*η[LI[{w, z}]]+PDNP[{3, -NP}][η[LI[{w, z}]]], 
 Θ[{4, -NP}][η[LI[{w, z}]]] ->(-(w*αDyad[])- z*βDyad†[])*η[LI[{w, z}]]+PDNP[{4, -NP}][η[LI[{w, z}]]]}

GHPDerivativesToFrame=%;

%/.Rule->Equal;

Solve[%,Cases[%,PDNP[_]@_,Infinity]]//Flatten

FrameToGHPDerivatives=%;

We transform previous rules in delayed rules with patterns which can be used for any weighted quantity

GHPDerivativesToFrame/.Rule->RuleDelayed/.η[LI@{w,z}]->η

%/.Θ[comp__]@η:>Θ[comp]@η_

GHPToNP=(%/.w:>First@GHPWeightOf@η/.z:>Last@GHPWeightOf@η)

FrameToGHPDerivatives/.Rule->RuleDelayed/.η[LI@{w,z}]->η

%/.PDNP[comp__]@η:>PDNP[comp]@η_

NPToGHP=(%/.w:>First@GHPWeightOf@η/.z:>Last@GHPWeightOf@η)

Each of the quantities þ(Subscript[η,  ]^({w, z})), þ'(Subscript[η,  ]^({w, z})), ð(Subscript[η,  ]^({w, z})), ð'(Subscript[η,  ]^({w, z})) is a spin weighted quantity. These are the specific values for the weights of each of them.

GHPWeightOf@Θ[{1,-NP}]^={1,1};
GHPWeightOf@Θ[{2,-NP}]^={-1,-1};
GHPWeightOf@Θ[{3,-NP}]^={1,-1};
GHPWeightOf@Θ[{4,-NP}]^={-1,1};

We also need to teach GHPWeightOf how to behave when acting on differential expressions.

GHPWeightOf[Θ[ind_?CIndexQ]@sc_]:={Part[GHPWeightOf@Θ[ind],1]+Part[GHPWeightOf@sc,1],Part[GHPWeightOf@Θ[ind],2]+Part[GHPWeightOf@sc,2]};

Commutation of the GHP differential operators

In this subsection we work out the commutation relations of each of the GHP operators. The commutator of two GHP operators is a new differential operator which acts on a generic spin weighted scalar (Subscript[η,  ]^({w, z})).

This is the commutation between two generic GHP operators.

Θ[-{a,NP}]@Θ[-{b,NP}]@η[LI@{w,z}]-Θ[-{b,NP}]@Θ[-{a,NP}]@η[LI@{w,z}]

We expand this into components in order to obtain the set of commutation relations.

Delete[Union@Flatten@ComponentArray@%,1]

Union[%,SameTest->(-#1===#2&)]

Union[%,SameTest->(Dagger@#1===#2&)]

Equal[#,#//.GHPToNP]&/@%

%/.(NPCommutators/.ψ[]->η[LI@{w,z}]/.Equal->Rule);

%/.(Map[Dagger,NPCommutators,{2}]/.ψ[]->η[LI@{w,z}]/.Equal->Rule);

Map[FullSimplify,%,{2}]

We use the Newman-Penrose equations on this relation.

%/.(NPRicci/.Equal->Rule);

%/.(NPRicci†/.Equal->Rule);

Map[Simplify,%,{2}]

Finally we write δ(Subscript[η,  ]^({w, z})), (OverBar[δ])(Subscript[η,  ]^({w, z})) in terms of ð(Subscript[η,  ]^({w, z})),  ð'(Subscript[η,  ]^({w, z})) and simplify the resulting expression.

%/.NPToGHP;

Map[FullSimplify,%,{2}]

GHPCommutators=%;

We check that everything is OK

Map[GHPWeightOf,GHPCommutators,{2}]

Ricci identities in the GHP formalism

In this subsection we use the Newman-Penrose Ricci identities (Newman-Penrose equations) to find a set of equations which only contain the GHP differential operators and spin weighted quantities. This set of equations is known as GHP equations or compacted spin coefficient equations.

These are the weighted spin coefficients.

GHPSpinCoefficients

These are the NP differentials of these spin coefficients.

Flatten@Outer[PDNP[#1][#2]&,{{1,-NP},{2,-NP},{3,-NP},{4,-NP}},GHPSpinCoefficients,1]

We compute the GHP differentials of the weighted Newman-Penrose spin coefficients.

Rule[#,#/.NPToGHP]&/@%

With this information we can render the Newman-Penrose equations in terms of the GHP differential operators.

NPRicci/.%

Simplify//@%

We are interested in these equations which only contain weighted spin coefficients and GHP operators. These are

Part[%,Union[First/@Position[%,Θ[_]@_]]]

We may write these equations in an alternative way.

Solve[%,Union@Cases[%,Θ[__]@_,Infinity]]//Flatten

FullSimplify//@%

%/.Rule->Equal

Previous set of equations is known as GHP equations or compacted spin coefficient equations.

Length[GHPRicci=%]

Bianchi identities in the GHP formalism

Each of the components of the curvature spinors is a weighted scalar. Using this property it is possible to rewrite the Newman-Penrose form of the Bianchi identities in terms of spin weighted quantities. This is accomplished in this subsection.

We write the differentials of the curvature components which appear in the NP Bianchi identities in terms of differentials written in ters of the GHP operators.

NPBianchi/.NPToGHP

Simplify//@%

We may write these equations in an alternative way.

Solve[%,Union@Cases[%,Θ[__]@_,Infinity]]//Flatten

FullSimplify//@%

%/.Rule->Equal

Previous set of equations is known as GHP Bianchi identities or compacted Bianchi Identities.

Length[GHPBianchi=%]

4. Quick start

In this section we show how to use in practical applications the NP and GHP equations computed in previous sections. This is intended to be a short tutorial which enables the user to start working as quick as possible with the equations of the NP and GHP formalisms, so one does not need to read the contents of previous sections to use it. However, to take full advantage of the flexibility offered by our implementation and the remaining features of xAct`,  the complete knowledge of sections 1,2 and 3 is needed

The basic variables of the NP and GHP formalisms are the spin coefficients and the components of the curvature tensor. These are stored in lists.

NPSpinCoefficients

NPCVComponents

To type any of these quantities you need to know the imput form of them. This is achieved with the Mathematica command InputForm. For example, let us display the input form of the spin coefficient γ:

NPSpinCoefficients[[3]]//InputForm

Recall that Greek letters are typed by using the key "esc" followed by the Latin name of the letter followed by "esc". Hence

γDyad[]

Other essential ingredient of the NP and GHP formalisms are the frame differentiations. In the NP formalism these are just the directional derivatives associated to the four elements of the null tetrad. To see how they are typed, we consider their action on the spin coefficient  γ.

{PDNP[{1,-NP}]@γDyad[],PDNP[{2,-NP}]@γDyad[],PDNP[{3,-NP}]@γDyad[],PDNP[{4,-NP}]@γDyad[]}

The head PDNP denotes a generic NP operator associated to the null tetrad, whereas the arguments {1,-NP}, ... {4,-NP} are used to refer to each of the directional derivatives of the null tetrad elements. In this way {1,-NP} means the first element of the null tetrad, {2,-NP} the second element and so on. The elements of the null tetrad are numbered according to the usual convention. In the case of the GHP formalism, we have to take into account that only weighted quantities appear in the formalism. All the components of the Riemann tensor are weighted, but not all the spin coefficients are so. The weighted spin coefficients are  stored in the following list.

GHPSpinCoefficients

Let us take κ: the action of the four GHP operators on it is

{Θ[{1,-NP}]@κDyad[],Θ[{2,-NP}]@κDyad[],Θ[{3,-NP}]@κDyad[],Θ[{4,-NP}]@κDyad[]}

In this case, the head Θ (typed esc-Q-esc) is the notation for a generic GHP differential operator while 
{1,-NP},..,{4,-NP} are, as before, the labels for each of the elements of the null tetrad. We can transform the GHP differentials into NP differentials as follows.

%/.GHPToNP

NP differentials can be also transformed back into GHP differentials.

%/.NPToGHP

%//Simplify

Previous operations can be performed on any weighted quantity and the appropriate weights will be automatically inserted. For example:

{Θ[{1,-NP}]@PsiCDe4Dyad[],Θ[{2,-NP}]@PsiCDe4Dyad[],Θ[{3,-NP}]@PsiCDe4Dyad[],Θ[{4,-NP}]@PsiCDe4Dyad[]}

%//.GHPToNP

The basic equations of each formalism are stored in lists. These are the names of the lists and the correspondences:

Newman-Penrose commutation relations:

NPCommutators

Newman-Penrose Ricci identities:

NPRicci

Newman-Penrose Bianchi identities:

NPBianchi

GHP commutators acting on a generic quantity (Subscript[η,  ]^({w, z}))of boost weight w and spin weight z.

GHPCommutators

GHP Ricci identities:

GHPRicci

GHP Bianchi identities:

GHPBianchi

Within the GHP formalism any expression must be weighted. The command GHPWeightOf will compute the weight of any expression.

?GHPWeightOf

For example: take one of the GHP Bianchi identities:

GHPBianchi[[2]]

We compute the GHP weight of the right hand side of this relation.

GHPWeightOf@%[[2]]

Finally we explain how to compute the action of the GHP commutators on any quantity. For example suppose that we wish to compute the commutation of þ and ð' on the scalar (Subscript[Ψ, 4]). First of all, we look up in the list of GHP commutators the commutation relation we wish to use. In our case this is

GHPCommutators[[4]]

Next we replace (Subscript[η,  ]^({w, z})) by  (Subscript[Ψ, 4]) and the weights {w, z} by their values. This is accomplished as follows

%/.{η@LI@{w,z}->PsiCDe4Dyad[],w->First@GHPWeightOf@PsiCDe4Dyad[],z->Last@GHPWeightOf@PsiCDe4Dyad[]}