The procedure petrov is for determining the Petrov type of a given Weyl tensor in Newman-Penrose form.  The Petrov classification of the Weyl tensor is a result of determining the multiplicity of the roots of the following quartic polynomial (Q) in z:

where the psi values are the Newman-Penrose Weyl tensor components.  Given the coefficients psi[i], the petrov algorithm returns the Petrov type by using quartic theory.  The different cases are outlined in the table below.

The algorithm uses the zero/nonzero nature of the coefficients as well as the zero/nonzero nature of some expressions in the coefficients to determine the Petrov type.  Note that, in view of the structure of equation (Q), any common factor amongst the ${\mathrm{\psi }}_i$ can be removed before the algorithm is called without changing the result.

The ${\mathrm{\psi }}_i$ coefficients for a given null tetrad may be calculated using the tensor[npcurve] procedure.  It is important that the coefficients be in a simplified form.  This is especially true if one or more of the coefficients is identically zero.  For added efficiency it is suggested that any common factor of all the coefficients be removed before calling petrov. The functions ?content and ?primpart can help here.  See ?tensor[act] for help on simplification of the NP curvature components produced by tensor[npcurve].

The Petrov classification algorithm may be accessed with the command

where psi is an array indexed from 0 to 4 which contains the Newman-Penrose Weyl tensor components, and where the options may be both, one, or none of: 'verify'='name' and 'simp'.  The procedure petrov returns the Petrov type that it determines.

If 'simp' is specified then the ${\mathrm{\psi }}_i$ will be simplified using an internal routine. This should be avoided by making sure the coefficients are in their most simplified form before invoking petrov.

The procedure petrov calculates expressions and tests when some of them are identically zero. The zero test may fail if some identities are not applied.  For example, the expression cos(x)^2+sin(x)^2-1 is not known to be zero by petrov .  Therefore, it is important to verify that any determined nonzero expressions are in fact nonzero. The procedure Testzero() is used to check whether the appropriate expressions are zero, see below. The nonzero values will be returned in name if the 'verify' option is given in the call to petrov.  Thus, the command petrov(psi, 'simp', 'verify'='NONzero') (equivalently, petrov(psi, 'verify'='NONzero', 'simp')) will invoke the simplification of the psi components, classify the components, and then return the nonzero values in the variable NONzero for verification.

If you would like to add a simplification to petrov, then define the procedure `tensor/petrov/simp` which accepts one argument and returns a simplified form of the argument.  This simplification routine will be automatically applied whenever the routine does any internal simplification of computed expressions.  For example, the procedure `tensor/petrov/simp` := proc(a) simplify(a,trig) end proc; could be used to simplify the expression cos(x)^2+sin(x)^2-1 to zero.  For more information, see ?tensor[simp].

The environment procedure Testzero is used to control the determination of whether its argument is equal to zero. If you write your own procedure, it should return true in that case. For example, Testzero:=testeq will use a fast random tester. A stronger version (but slower) is Testzero:=proc(u) evalb(simplify(u,trig)=0) end proc: Since this procedure is an environment variable, it obeys the rules for environment variables, see ?environment for more information.

This function is part of the tensor package, and can be used in the form petrov(..) only after performing the command with(tensor), or with(tensor, petrov).  The function can always be accessed in the long form tensor[petrov].

$\mathrm{with}\left(\mathrm{tensor}\right)\:$

$\mathrm{\psi }≔\mathrm{array}\left(0..4\,\left[1-x^2\,1\,0\,x\,1-x\right]\right)\:$

$\mathrm{petrov}\left(\mathrm{\psi }\,'\mathrm{verify}'=\mathrm{NONzero}\right)$

$\mathrm{type\_I}$

$\mathrm{NONzero}$

$\left[\mathrm{V\_}=-x^4+x^2+x-1\,\mathrm{I\_}=x^3-x^2-5x+1\,\mathrm{J\_}=x^4-x^2+x-1\,\mathrm{D\_}=x^9-30x^8-12x^7+86x^6-75x^4-38x^3-9x^2+39x-26\right]$

$\mathrm{factor}\left(\mathrm{subs}\left(\mathrm{NONzero}\,\mathrm{V\_}\right)\right)$

$-\left(-1+x\right)\left(x^3+x^2-1\right)$

Testzero:=proc(u) evalb( simplify(u, {x^3+x^2-1})=0) end proc:

$\mathrm{petrov}\left(\mathrm{\psi }\,'\mathrm{verify}'='\mathrm{NONzero2}'\right)$

$\mathrm{type\_I}$

$\mathrm{constr2}≔\mathrm{simplify}\left(\mathrm{NONzero2}\,\left\{x^3+x^2-1\right\}\right)$

$\mathrm{constr2}≔\left[\mathrm{U\_}=-2x^2+x+2\,\mathrm{W\_}=-2x^2-17x+2\right]$

$\mathrm{resultant}\left(\mathrm{subs}\left(\mathrm{constr2}\,\mathrm{U\_}\right)\,x^3+x^2-1\,x\right)$

$19$

Letniowski, F.W., and McLenaghan, R. G. "An Improved Algorithm for Quartic Equation Classification and Petrov Classification." General Relativity and Gravitation, Vol. 20. Plenum Publishing Corporation, (1988): 463-483.

Note: The labels used to return the nonzero quantities, using the 'verify' option correspond to the quantities used in this article, with an underscore appended.