NP Calculator

Edgar Gasperin
Written in Mathematica 11.2
3 Feb 2025

Given a null tetrad in some coordinates, this  notebook  computes  the  spin  coefficients  and  curvature  of the  NP  formalism.
The example given here takes about 10 minutes to run from beginning to end.

NP  calculator

Load packages and general set up

<<xAct`xTensor`

DefManifold[M4,4,{a,b,c,d,f,p,h,i,j,k,l,n,v,w}]
ApplyRule[expr_]:=MakeRule[Evaluate[List@@expr],MetricOn->All,ContractMetrics->True]
ApplyRuleN[expr_]:=MakeRule[Evaluate[List@@expr]]
$MixedDers=False;
Off[ToCanonical::noident]
$PrePrint=ScreenDollarIndices;

<<xAct`xCoba`

Coordinates and null frame

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

DefChart[SomeCoords,M4,{0,1,2,3},{t[],r[],θ[],φ[]}]

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

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

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

PrintAs@mNP†^="(Overscript[m, -])"

The  specific  example  presented  here  is  for  the Kinnersley tetrad of the Kerr spacetime.
The expressions in the next cell are  taken  from  equation  (4.4)  of
“Perturbations  of  a  rotating  black  hole  I . Fundamental  equations  for  gravitational, electromagnetic, and  neutrino - field  perturbations”   by  Saul  A . Teukolsky

Null Tetrad in coordinates

Now we specify components of the metric in that chart. First, declare constants.

DefConstantSymbol[Mass,PrintAs->"m"]
DefConstantSymbol[Ang,PrintAs->"a"]

DeltaShorthand/:MakeBoxes[DeltaShorthand,StandardForm]:="Δ";
SigmaShorthand/:MakeBoxes[SigmaShorthand,StandardForm]:="Σ";

SigmaShorthand
DeltaShorthand

lcomps={(r[]^2+Ang^2)/DeltaShorthand,1,0,Ang/DeltaShorthand}
ncomps=(1/(2*SigmaShorthand)){(r[]^2+Ang^2),-DeltaShorthand,0,Ang}
mcomps={I*Ang*Sin[θ[]],0,1,I*Csc[θ[]]}/(Sqrt[2](r[]+I*Ang*Cos[θ[]]))

SubsShorthands={DeltaShorthand-> r[]^2+Ang^2-2*Mass*r[] ,SigmaShorthand-> r[]^2+Ang^2*Cos[θ[]]^2}

AllComponentValues[lNP[{a,SomeCoords}],Expand@Evaluate[lcomps/.SubsShorthands]]
AllComponentValues[nNP[{a,SomeCoords}],Expand@Evaluate[ncomps/.SubsShorthands]]
AllComponentValues[mNP[{a,SomeCoords}],Expand@Evaluate[mcomps/.SubsShorthands]]
AllComponentValues[mNP†[{a,SomeCoords}],Expand@Dagger[mcomps/.SubsShorthands]]

The spin coefficients

Definitions of the NP directional derivatives

The directional derivatives

DefInertHead[DNP,PrintAs-> "D"]
DefInertHead[DELNP,PrintAs-> "Δ"]
DefInertHead[delNP,PrintAs-> "δ"]
DefInertHead[delbarNP,PrintAs-> "(Overscript[δ, -])"]

DNP[_?ConstantQ]:=0
DNP[x_+y_]:=DNP[x]+DNP[y]
DNP[x_ y_]:=DNP[x]y+DNP[y]x
DNP[g[_,_]]:=0
(**)
DELNP[_?ConstantQ]:=0
DELNP[x_+y_]:=DELNP[x]+DELNP[y]
DELNP[x_ y_]:=DELNP[x]y+DELNP[y]x
DELNP[g[_,_]]:=0
(**)
delNP[_?ConstantQ]:=0
delNP[x_+y_]:=delNP[x]+delNP[y]
delNP[x_ y_]:=delNP[x]y+delNP[y]x
delNP[g[_,_]]:=0
(**)
delbarNP[_?ConstantQ]:=0
delbarNP[x_+y_]:=delbarNP[x]+delbarNP[y]
delbarNP[x_ y_]:=delbarNP[x]y+delbarNP[y]x
delbarNP[g[_,_]]:=0

DNPtoCD=DNP[expr_]:>Module[{a},lNP[a]CD[-a][expr]]
DELNPtoCD=DELNP[expr_]:>Module[{a},nNP[a]CD[-a][expr]]
delNPtoCD=delNP[expr_]:>Module[{a},mNP[a]CD[-a][expr]]
delbarNPtoCD=delbarNP[expr_]:>Module[{a},mNP†[a]CD[-a][expr]]

DaggerNPDirDers={Dagger@DNP[x_ ]:> DNP[Dagger@x],Dagger@DELNP[x_ ]:>DELNP[Dagger@x],Dagger@delNP[x_ ]:>delbarNP[Dagger@x],Dagger@delbarNP[x_ ]:>delNP[Dagger@x]}

Definition of the spin coefficients as directional derivatives

DefScalarFunction[kappaNP,Dagger->Complex,PrintAs->"κ"]
PrintAs@kappaNP†^="(Overscript[κ, -])"
DefScalarFunction[tauNP,Dagger->Complex,PrintAs->"τ"]
PrintAs@tauNP†^="(Overscript[τ, -])"
DefScalarFunction[sigmaNP,Dagger->Complex,PrintAs->"σ"]
PrintAs@sigmaNP†^="(Overscript[σ, -])"
DefScalarFunction[rhoNP,Dagger->Complex,PrintAs->"ρ"]
PrintAs@rhoNP†^="(Overscript[ρ, -])"
DefScalarFunction[piNP,Dagger->Complex,PrintAs->"π"]
PrintAs@piNP†^="(Overscript[π, -])"
DefScalarFunction[nuNP,Dagger->Complex,PrintAs->"ν"]
PrintAs@nuNP†^="(Overscript[ν, -])"
DefScalarFunction[muNP,Dagger->Complex,PrintAs->"μ"]
PrintAs@muNP†^="(Overscript[μ, -])"
DefScalarFunction[lambdaNP,Dagger->Complex,PrintAs->"λ"]
PrintAs@lambdaNP†^="(Overscript[λ, -])"
DefScalarFunction[epsilonNP,Dagger->Complex,PrintAs->"ϵ"]
PrintAs@epsilonNP†^="(Overscript[ϵ, -])"
DefScalarFunction[gammaNP,Dagger->Complex,PrintAs->"γ"]
PrintAs@gammaNP†^="(Overscript[γ, -])"
DefScalarFunction[betaNP,Dagger->Complex,PrintAs->"β"]
PrintAs@betaNP†^="(Overscript[β, -])"
DefScalarFunction[alphaNP,Dagger->Complex,PrintAs->"α"]
PrintAs@alphaNP†^="(Overscript[α, -])"

kappaNPDef=kappaNP==mNP[a]DNP@lNP[-a]
tauNPDef=tauNP==mNP[a]DELNP@lNP[-a]
sigmaNPDef=sigmaNP==mNP[a]delNP@lNP[-a]
rhoNPDef=rhoNP==mNP[a]delbarNP@lNP[-a]
(**)
piNPDef=piNP==-mNP†[a]DNP@nNP[-a]
nuNPDef=nuNP==-mNP†[a]DELNP@nNP[-a]
muNPDef=muNP==-mNP†[a]delNP@nNP[-a]
lambdaNPDef=lambdaNP==-mNP†[a]delbarNP@nNP[-a]
(**)
epsilonNPDef=epsilonNP==(1/2)(nNP[a]DNP@lNP[-a]-mNP†[a]DNP@mNP[-a])
gammaNPDef=gammaNP==(1/2)(nNP[a]DELNP@lNP[-a]-mNP†[a]DELNP@mNP[-a])
betaNPDef=betaNP==(1/2)(nNP[a]delNP@lNP[-a]-mNP†[a]delNP@mNP[-a])
alphaNPDef=alphaNP==(1/2)(nNP[a]delbarNP@lNP[-a]-mNP†[a]delbarNP@mNP[-a])

DNPtoPD=DNP[expr_]:>Module[{a},lNP[a]PD[-a][expr]]
DELNPtoPD=DELNP[expr_]:>Module[{a},nNP[a]PD[-a][expr]]
delNPtoPD=delNP[expr_]:>Module[{a},mNP[a]PD[-a][expr]]
delbarNPtoPD=delbarNP[expr_]:>Module[{a},mNP†[a]PD[-a][expr]]

NP - Commutators

General expressions

DefScalarFunction[testscalar, PrintAs->"ϕ"]

DNP[testscalar]
DELNP[testscalar]
delNP[testscalar]
delbarNP[testscalar]

NP Commutators no torsion condition taken from “Advanced General Relativity” by John Stewart

Commutator1=DELNP@DNP@testscalar-DNP@DELNP@testscalar==(gammaNP+gammaNP†)*DNP@testscalar +(epsilonNP+epsilonNP†)*DELNP@testscalar -(tauNP†+piNP)delNP@testscalar-(tauNP+piNP†)delbarNP@testscalar
Commutator2=delNP@DNP@testscalar-DNP@delNP@testscalar == (alphaNP†+betaNP-piNP†)DNP@testscalar +kappaNP*DELNP@testscalar - (rhoNP† + epsilonNP- epsilonNP†)*delNP@testscalar - sigmaNP*delbarNP@testscalar
Commutator3=delNP@DELNP@testscalar-DELNP@delNP@testscalar==-nuNP†*DNP@testscalar + (tauNP-alphaNP†-betaNP)*DELNP@testscalar+(muNP-gammaNP+gammaNP†)*delNP@testscalar +lambdaNP†*delbarNP@testscalar
Commutator4=delbarNP@delNP@testscalar-delNP@delbarNP@testscalar== (muNP†-muNP)*DNP@testscalar+(rhoNP†-rhoNP)*DELNP@testscalar+(alphaNP-betaNP†)*delNP@testscalar -(alphaNP†-betaNP)*delbarNP@testscalar

Dagger@Commutator2;
%//.DaggerNPDirDers;
DaggerCommutator2=%
(***)
Dagger@Commutator3;
%//.DaggerNPDirDers;
DaggerCommutator3=%

NPCommutators={Commutator1,Commutator2,Commutator3,Commutator4,DaggerCommutator2,DaggerCommutator3}

(** NP derivarives of coordinates **)

(******* T ********)
DNP[ScalarsOfChart[SomeCoords][[1]]];
%==(%/.DNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DNPT=%
(***)
DELNP[ScalarsOfChart[SomeCoords][[1]]];
%==(%/.DELNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DELNPT=%
(***)
delNP[ScalarsOfChart[SomeCoords][[1]]];
%==(%/.delNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delNPT=%
(***)
delbarNP[ScalarsOfChart[SomeCoords][[1]]];
%==(%/.delbarNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delbarNPT=%
(******* R ********)
DNP[ScalarsOfChart[SomeCoords][[2]]];
%==(%/.DNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DNPR=%
(***)
DELNP[ScalarsOfChart[SomeCoords][[2]]];
%==(%/.DELNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DELNPR=%
(***)
delNP[ScalarsOfChart[SomeCoords][[2]]];
%==(%/.delNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delNPR=%
(***)
delbarNP[ScalarsOfChart[SomeCoords][[2]]];
%==(%/.delbarNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delbarNPR=%
(******* theta ********)
DNP[ScalarsOfChart[SomeCoords][[3]]];
%==(%/.DNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DNPtheta=%
(***)
DELNP[ScalarsOfChart[SomeCoords][[3]]];
%==(%/.DELNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DELNPtheta=%
(***)
delNP[ScalarsOfChart[SomeCoords][[3]]];
%==(%/.delNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delNPtheta=%
(***)
delbarNP[ScalarsOfChart[SomeCoords][[3]]];
%==(%/.delbarNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delbarNPtheta=%
(******* phi ********)
DNP[ScalarsOfChart[SomeCoords][[4]]];
%==(%/.DNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DNPphi=%
(***)
DELNP[ScalarsOfChart[SomeCoords][[4]]];
%==(%/.DELNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
DELNPphi=%
(***)
delNP[ScalarsOfChart[SomeCoords][[4]]];
%==(%/.delNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delNPphi=%
(***)
delbarNP[ScalarsOfChart[SomeCoords][[4]]];
%==(%/.delbarNPtoCD);
ContractBasis[%];
(*ToValues[%];*)
delbarNPphi=%

NPdersCoordBasis={DNPT,DNPR,DNPtheta,DNPphi,DELNPT,DELNPR,DELNPtheta,DELNPphi,delNPT,delNPR,delNPtheta,delNPphi,delbarNPT,delbarNPR,delbarNPtheta,delbarNPphi};
ApplyRuleNPdersCoordBasis=Flatten[ApplyRuleN/@NPdersCoordBasis];

NPCommutators;
%/.testscalar->ScalarsOfChart[SomeCoords][[1]];
%/.ApplyRuleNPdersCoordBasis;
NPCommutatorsT=%
(***)
NPCommutators;
%/.testscalar->ScalarsOfChart[SomeCoords][[2]];
%/.ApplyRuleNPdersCoordBasis;
NPCommutatorsR=%
(***)
NPCommutators;
%/.testscalar->ScalarsOfChart[SomeCoords][[3]];
%/.ApplyRuleNPdersCoordBasis;
NPCommutatorsTheta=%
(***)
NPCommutators;
%/.testscalar->ScalarsOfChart[SomeCoords][[4]];
%/.ApplyRuleNPdersCoordBasis;
NPCommutatorsPhi=%

NPCommutatorsCoordComps=Flatten@{NPCommutatorsT,NPCommutatorsR,NPCommutatorsTheta,NPCommutatorsPhi};

Spin Coefficients main calculation

NPCommutatorsCoordComps;
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
%//ToValues//ContractBasis//ToValues;
NPCommutatorsCoordCompsExplicit=%;

SpinCoefsSolvedForPresentSetup=Solve[Flatten@{NPCommutatorsCoordCompsExplicit},{kappaNP,tauNP,sigmaNP,rhoNP,epsilonNP,gammaNP,betaNP,alphaNP,piNP,nuNP,muNP,lambdaNP,(***)kappaNP†,tauNP†,sigmaNP†,rhoNP†,epsilonNP†,gammaNP†,betaNP†,alphaNP†,piNP†,nuNP†,muNP†,lambdaNP†}];

SpinCoefSolved=Flatten@SpinCoefsSolvedForPresentSetup/.{Rule->Equal};

Spin coefficients list

SimplifyRHS[x_]:=x[[1]]==FullSimplify[x[[2]]]

KappaNPExp=SimplifyRHS[SpinCoefSolved[[1]]]
TauNPExp=SimplifyRHS[SpinCoefSolved[[2]]]
SigmaNPExp=SimplifyRHS[SpinCoefSolved[[3]]]
RhoNPExp=SimplifyRHS[SpinCoefSolved[[4]]]
EpsilonNPExp=SimplifyRHS[SpinCoefSolved[[5]]]
GammaNPExp=SimplifyRHS[SpinCoefSolved[[6]]]
BetaNPExp=SimplifyRHS[SpinCoefSolved[[7]]]
AlphaNPExp=SimplifyRHS[SpinCoefSolved[[8]]]
PiNPExp=SimplifyRHS[SpinCoefSolved[[9]]]
NuNPExp=SimplifyRHS[SpinCoefSolved[[10]]]
MuNPExp=SimplifyRHS[SpinCoefSolved[[11]]]
LambdaNPExp=SimplifyRHS[SpinCoefSolved[[12]]]

SpinCoefsNoDagger={KappaNPExp,TauNPExp,SigmaNPExp,RhoNPExp,EpsilonNPExp,GammaNPExp,BetaNPExp,AlphaNPExp,PiNPExp,NuNPExp,MuNPExp,LambdaNPExp};
SpinCoefsDagger={Dagger@KappaNPExp,Dagger@TauNPExp,Dagger@SigmaNPExp,Dagger@RhoNPExp,Dagger@EpsilonNPExp,Dagger@GammaNPExp,Dagger@BetaNPExp,Dagger@AlphaNPExp,Dagger@PiNPExp,Dagger@NuNPExp,Dagger@MuNPExp,Dagger@LambdaNPExp};

SpinCoefsExact=Flatten@{SpinCoefsNoDagger,SpinCoefsDagger};

ApplyRuleSpinCoefsExact=Flatten[ApplyRuleN/@SpinCoefsExact];

The NP equations

The components of the tracefree Ricci  satisfy (Subscript[Φ, ab])=(Subscript[(Overscript[Φ, -]), ba]) therefore it encodes 9 real quantities. Then, since  Λ is the trace one has the 10 components of the Ricci tensor.

DefScalarFunction[Phi00,PrintAs->"(Subscript[Φ, 00])"]
DefScalarFunction[Phi01,PrintAs->"(Subscript[Φ, 01])"]
DefScalarFunction[Phi02,PrintAs->"(Subscript[Φ, 02])"]
DefScalarFunction[Phi10,PrintAs->"(Subscript[Φ, 10])"]
DefScalarFunction[Phi11,PrintAs->"(Subscript[Φ, 11])"]
DefScalarFunction[Phi12,PrintAs->"(Subscript[Φ, 12])"]
DefScalarFunction[Phi20,PrintAs->"(Subscript[Φ, 20])"]
DefScalarFunction[Phi21,PrintAs->"(Subscript[Φ, 21])"]
DefScalarFunction[Phi22,PrintAs->"(Subscript[Φ, 22])"]
DefScalarFunction[RicciScalarNP,PrintAs->"Λ"]

The Weyl Scalars encoding the 10 real independent components of the Weyl tensor.

DefScalarFunction[Psi0,PrintAs->"(Subscript[Ψ, 0])"]
DefScalarFunction[Psi1,PrintAs->"(Subscript[Ψ, 1])"]
DefScalarFunction[Psi2,PrintAs->"(Subscript[Ψ, 2])"]
DefScalarFunction[Psi3,PrintAs->"(Subscript[Ψ, 3])"]
DefScalarFunction[Psi4,PrintAs->"(Subscript[Ψ, 4])"]

The following are the Newman - Penrose equations as given in “Advanced General Relativity” by John Stewart

NPfieldEqa=DNP@rhoNP-delbarNP@kappaNP==(rhoNP^2+sigmaNP*Dagger[sigmaNP])+(epsilonNP+Dagger[epsilonNP])*rhoNP-Dagger[kappaNP]tauNP-kappaNP*(3alphaNP+Dagger[betaNP]-piNP)+Phi00
(**)
NPfieldEqb=DNP@sigmaNP-delNP@kappaNP==(rhoNP+Dagger@rhoNP+3epsilonNP-Dagger@epsilonNP)sigmaNP-(tauNP-Dagger@piNP+Dagger@alphaNP+3betaNP)*kappaNP+Psi0
(**)
NPfieldEqc=DNP@tauNP-DELNP@kappaNP==(tauNP+Dagger@piNP)rhoNP+(Dagger@tauNP+piNP)sigmaNP+(epsilonNP-Dagger@epsilonNP)tauNP-(3gammaNP+Dagger@gammaNP)kappaNP+Psi1+Phi01
(**)
NPfieldEqd=DNP@alphaNP-delbarNP@epsilonNP ==(rhoNP+Dagger@epsilonNP-2epsilonNP)alphaNP+betaNP*Dagger@sigmaNP-(Dagger@betaNP)*epsilonNP-kappaNP*lambdaNP-(Dagger@kappaNP)*gammaNP+ (epsilonNP+rhoNP)*piNP+Phi10
(**)
NPfieldEqe=DNP@betaNP-delNP@epsilonNP==(alphaNP+piNP)*sigmaNP+(Dagger@rhoNP-Dagger@epsilonNP)*betaNP-(muNP+gammaNP)*kappaNP-(Dagger@alphaNP-Dagger@piNP)epsilonNP+Psi1
(**)
NPfieldEqf=DNP@gammaNP-DELNP@epsilonNP==(tauNP+Dagger@piNP)alphaNP+(Dagger@tauNP+piNP)*betaNP-(epsilonNP+Dagger@epsilonNP)gammaNP-(gammaNP+Dagger@gammaNP)epsilonNP+tauNP*piNP-nuNP*kappaNP+Psi2-RicciScalarNP+Phi11
(**)
NPfieldEqg=DNP@lambdaNP-delbarNP@piNP==(rhoNP-3epsilonNP+Dagger@epsilonNP)lambdaNP+(Dagger@sigmaNP)*muNP+(piNP+alphaNP-Dagger@betaNP)piNP-nuNP*Dagger@kappaNP+Phi20
(**)
NPfieldEqh=DNP@muNP-delNP@piNP==(Dagger@rhoNP-epsilonNP-Dagger@epsilonNP)muNP+sigmaNP*lambdaNP+(Dagger@piNP-Dagger@alphaNP+betaNP)piNP-nuNP*kappaNP+Psi2+2*RicciScalarNP
(**)
NPfieldEqi=DNP@nuNP-DELNP@piNP==(piNP+Dagger@tauNP)muNP+(Dagger@piNP+tauNP)lambdaNP+(gammaNP-Dagger@gammaNP)piNP-(3epsilonNP+Dagger@epsilonNP)nuNP+Psi3+Phi21
(**)
NPfieldEqj=DELNP@lambdaNP-delbarNP@nuNP==-(muNP+Dagger@muNP+3gammaNP-Dagger@gammaNP)lambdaNP+(3alphaNP+Dagger@betaNP+piNP-Dagger@tauNP)nuNP-Psi4
(**)
NPfieldEqk=delNP@rhoNP-delbarNP@sigmaNP==(Dagger@alphaNP+betaNP)rhoNP-(3alphaNP-Dagger@betaNP)sigmaNP+(rhoNP-Dagger@rhoNP)tauNP+(muNP-Dagger@muNP)kappaNP-Psi1+Phi01
(**)
NPfieldEql=delNP@alphaNP-delbarNP@betaNP==muNP*rhoNP-lambdaNP*sigmaNP+alphaNP*Dagger@alphaNP+betaNP*Dagger@betaNP-2alphaNP*betaNP+(rhoNP-Dagger@rhoNP)gammaNP+(muNP-Dagger@muNP)epsilonNP-Psi2+RicciScalarNP+Phi11
(**)
NPfieldEqm=delNP@lambdaNP-delbarNP@muNP==(rhoNP-Dagger@rhoNP)nuNP+(muNP-Dagger@muNP)piNP+ (alphaNP+Dagger@betaNP)muNP+(Dagger@alphaNP-3betaNP)lambdaNP-Psi3+Phi21
(**)
NPfieldEqn=DELNP@muNP-delNP@nuNP==-(muNP+gammaNP+Dagger@gammaNP)*muNP-lambdaNP*Dagger@lambdaNP+(Dagger@nuNP)*piNP+(Dagger@alphaNP+3betaNP-tauNP)*nuNP-Phi22
(**)
NPfieldEqo=DELNP@betaNP-delNP@gammaNP==(Dagger@alphaNP+betaNP-tauNP)gammaNP-muNP*tauNP+sigmaNP*nuNP+epsilonNP*Dagger@nuNP+(gammaNP-Dagger@gammaNP-muNP)betaNP-alphaNP*Dagger@lambdaNP-Phi12
(**)
NPfieldEqp=DELNP@sigmaNP-delNP@tauNP==-(muNP-3gammaNP+Dagger@gammaNP)sigmaNP-(Dagger@lambdaNP)*rhoNP-(tauNP+betaNP-Dagger@alphaNP)tauNP+kappaNP*Dagger@nuNP-Phi02
(**)
NPfieldEqq=DELNP@rhoNP-delbarNP@tauNP==(gammaNP+Dagger@gammaNP-Dagger@muNP)rhoNP-sigmaNP*lambdaNP+(Dagger@betaNP-alphaNP-Dagger@tauNP)tauNP+nuNP*kappaNP-Psi2-2RicciScalarNP
(**)
NPfieldEqr=DELNP@alphaNP-delbarNP@gammaNP==(rhoNP+epsilonNP)nuNP-(tauNP+betaNP)lambdaNP+(Dagger@gammaNP-Dagger@muNP)alphaNP+ (Dagger@betaNP-Dagger@tauNP)gammaNP-Psi3

Observe that the NP equations is a overdetermined system of equations for {(Subscript[Φ, 00]),(Subscript[Φ, 01]),(Subscript[Φ, 02,])(Subscript[Φ, 10,])(Subscript[Φ, 11]),(Subscript[Φ, 12]),(Subscript[Φ, 20]),(Subscript[Φ, 21]),(Subscript[Φ, 22]),Λ,(Subscript[Ψ, 0]),(Subscript[Ψ, 1]),(Subscript[Ψ, 2]),(Subscript[Ψ, 3]),(Subscript[Ψ, 4])}
There are 18 NP field equations for 15 uknowns.  Observations:The only fields for which one has to take linear combinations of the above  equations are {Λ, (Subscript[Ψ, 2]),(Subscript[Φ, 11]),(Subscript[Φ, 01]), (Subscript[Φ, 21])}.
  To solve for {Λ, (Subscript[Ψ, 2]),(Subscript[Φ, 11])}  use  {  either h or g  and   { f &l } } . To solve for (Subscript[Φ, 01]) use {c & k} or { c & e} or { k& e}.
 To solve for  (Subscript[Φ, 21]) use {i  & m} or {i & e} or {m & e}

Here we select a subset of the NP equations.

NPfieldEqSubset={NPfieldEqa,NPfieldEqb,NPfieldEqc,NPfieldEqd,NPfieldEqe,NPfieldEqf,NPfieldEqg,NPfieldEqh,NPfieldEqi,NPfieldEqj(*,NPfieldEqk*),NPfieldEql(*NPfieldEqm*),NPfieldEqn,NPfieldEqo,NPfieldEqp(*,NPfieldEqq*),NPfieldEqr}

SolutionFromSubSetNP=Flatten[Solve[NPfieldEqSubset,{Phi00,Phi01,Phi02,Phi10,Phi11,Phi12,Phi20,Phi21,Phi22,RicciScalarNP,Psi0,Psi1,Psi2,Psi3,Psi4}]]/.Rule->Equal

Curvature

Weyl

SolutionFromSubSetNP[[15]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
Weyl4=%

SolutionFromSubSetNP[[14]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
Weyl3=%

SolutionFromSubSetNP[[13]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Function[x,x//PowerExpand],%,2];
MapAt[Together,%,2];
MapAt[Simplify,%,2];
Weyl2=%

SolutionFromSubSetNP[[12]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
Weyl1=%

SolutionFromSubSetNP[[11]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
Weyl0=%

Ricci

SolutionFromSubSetNP[[1]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci00=%

SolutionFromSubSetNP[[2]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci01=%

SolutionFromSubSetNP[[3]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci02=%

SolutionFromSubSetNP[[4]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci10=%

SolutionFromSubSetNP[[5]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci11=%

SolutionFromSubSetNP[[6]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci12=%

SolutionFromSubSetNP[[7]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci20=%

SolutionFromSubSetNP[[8]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Simplify,%,2];
TFRicci21=%

SolutionFromSubSetNP[[9]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Expand,%,2];
MapAt[Simplify,%,2];
TFRicci22=%

SolutionFromSubSetNP[[10]]
%/.DNPtoCD/.DELNPtoCD/.delNPtoCD/.delbarNPtoCD;
MapAt[Function[x,ToBasis[SomeCoords][x]],%,2];
MapAt[TraceBasisDummy,%,2];
MapAt[Simplify,%,2];
%//ToValues//PowerExpand;
%/.ApplyRuleSpinCoefsExact;
MapAt[Function[x,x//PowerExpand],%,2];
MapAt[Together,%,2];
MapAt[Simplify,%,2];
MapAt[TrigReduce,%,2];
LambdaCurvature=%

Summary

Weyl

Weyl4
Weyl3
Weyl2
Weyl1
Weyl0

Trace-Free Ricci

TFRicci00
TFRicci01
TFRicci02
TFRicci10
TFRicci11
TFRicci12
TFRicci20
TFRicci21
TFRicci22
LambdaCurvature

Spin coefficients

KappaNPExp
TauNPExp
SigmaNPExp
RhoNPExp
EpsilonNPExp
GammaNPExp
BetaNPExp
AlphaNPExp
PiNPExp
NuNPExp
MuNPExp
LambdaNPExp

TimeUsed[]