This worksheet demonstrates a few capabilities of SageManifolds (version 1.0, as included in SageMath 7.5) regarding the computation of the Simon-Mars tensor.

Click here to download the worksheet file (ipynb format). To run it, you must start SageMath within the Jupyter notebook, via the command `sage -n jupyter`

*NB:* a version of SageMath at least equal to 7.5 is required to run this worksheet:

In [1]:

```
version()
```

Out[1]:

First we set up the notebook to display mathematical objects using LaTeX rendering:

In [2]:

```
%display latex
```

Since some computations are quite long, we ask for running them in parallel on 8 cores:

In [3]:

```
Parallelism().set(nproc=8)
```

We declare the Kerr spacetime (or more precisely the part of the Kerr spacetime covered by Boyer-Lindquist coordinates) as a 4-dimensional manifold $\mathcal{M}$:

In [4]:

```
M = Manifold(4, 'M', latex_name=r'\mathcal{M}')
print(M)
```

The standard **Boyer-Lindquist coordinates** $(t,r,\theta,\phi)$ are introduced by declaring a chart $X$ on $\mathcal{M}$, via the method `chart()`

, the argument of which is a string expressing the coordinates names, their ranges (the default is $(-\infty,+\infty)$) and their LaTeX symbols:

In [5]:

```
X.<t,r,th,ph> = M.chart(r't r:(0,+oo) th:(0,pi):\theta ph:(0,2*pi):\phi')
print(X) ; X
```

Out[5]:

The 2 parameters $m$ and $a$ of the Kerr spacetime are declared as symbolic variables:

In [6]:

```
var('m, a', domain='real')
```

Out[6]:

Let us introduce the spacetime metric $g$ and set its components in the coordinate frame associated with Boyer-Lindquist coordinates, which is the current manifold's default frame:

In [7]:

```
g = M.lorentzian_metric('g')
rho2 = r^2 + (a*cos(th))^2
Delta = r^2 -2*m*r + a^2
g[0,0] = -(1-2*m*r/rho2)
g[0,3] = -2*a*m*r*sin(th)^2/rho2
g[1,1], g[2,2] = rho2/Delta, rho2
g[3,3] = (r^2+a^2+2*m*r*(a*sin(th))^2/rho2)*sin(th)^2
g.display()
```

Out[7]:

In [8]:

```
g[:]
```

Out[8]:

The Levi-Civita connection $\nabla$ associated with $g$:

In [9]:

```
nabla = g.connection() ; print(nabla)
```

As a check, we verify that the covariant derivative of $g$ with respect to $\nabla$ vanishes identically:

In [10]:

```
nabla(g).display()
```

Out[10]:

The default vector frame on the spacetime manifold is the coordinate basis associated with Boyer-Lindquist coordinates:

In [11]:

```
M.default_frame() is X.frame()
```

Out[11]:

In [12]:

```
X.frame()
```

Out[12]:

Let us consider the first vector field of this frame:

In [13]:

```
xi = X.frame()[0] ; xi
```

Out[13]:

In [14]:

```
print(xi)
```

The 1-form associated to it by metric duality is

In [15]:

```
xi_form = xi.down(g)
xi_form.set_name('xi_form', r'\underline{\xi}')
print(xi_form) ; xi_form.display()
```

Out[15]:

Its covariant derivative is

In [16]:

```
nab_xi = nabla(xi_form)
print(nab_xi) ; nab_xi.display()
```

Out[16]:

Let us check that the Killing equation is satisfied:

In [17]:

```
nab_xi.symmetrize().display()
```

Out[17]:

Equivalently, we check that the Lie derivative of the metric along $\xi$ vanishes:

In [18]:

```
g.lie_der(xi).display()
```

Out[18]:

Thank to Killing equation, $\nabla_g \underline{\xi}$ is antisymmetric. We may therefore define a 2-form by $F := - \nabla_g \xi$. Here we enforce the antisymmetry by calling the function antisymmetrize() on nab_xi:

In [19]:

```
F = - nab_xi.antisymmetrize()
F.set_name('F')
print(F)
F.display()
```

Out[19]:

We check that

In [20]:

```
F == - nab_xi
```

Out[20]:

The squared norm of the Killing vector is:

In [21]:

```
lamb = - g(xi,xi)
lamb.set_name('lambda', r'\lambda')
print(lamb)
lamb.display()
```

Out[21]:

Instead of invoking $g(\xi,\xi)$, we could have evaluated $\lambda$ by means of the 1-form $\underline{\xi}$ acting on the vector field $\xi$:

In [22]:

```
lamb == - xi_form(xi)
```

Out[22]:

or, using index notation as $\lambda = - \xi_a \xi^a$:

In [23]:

```
lamb == - ( xi_form['_a']*xi['^a'] )
```

Out[23]:

The Riemann curvature tensor associated with $g$ is

In [24]:

```
Riem = g.riemann()
print(Riem)
```

The component $R^0_{\ \, 123} = R^t_{\ \, r\theta\phi}$ is

In [25]:

```
Riem[0,1,2,3]
```

Out[25]:

The Ricci tensor:

In [26]:

```
Ric = g.ricci()
print(Ric)
```

Let us check that the Kerr metric is a vacuum solution of Einstein equation, i.e. that the Ricci tensor vanishes identically:

In [27]:

```
Ric.display()
```

Out[27]:

The Weyl conformal curvature tensor is

In [28]:

```
C = g.weyl()
print(C)
```

Let us exhibit two of its components $C^0_{\ \, 123}$ and $C^0_{\ \, 101}$:

In [29]:

```
C[0,1,2,3]
```

Out[29]:

In [30]:

```
C[0,1,0,1]
```

Out[30]:

To form the Simon-Mars tensor, we need the fully covariant (type-(0,4) tensor) form of the Weyl tensor (i.e. $C_{\alpha\beta\mu\nu} = g_{\alpha\sigma} C^\sigma_{\ \, \beta\mu\nu}$); we get it by lowering the first index with the metric:

In [31]:

```
Cd = C.down(g)
print(Cd)
```

The (monoterm) symmetries of this tensor are those inherited from the Weyl tensor, i.e. the antisymmetry on the last two indices (position 2 and 3, the first index being at position 0):

In [32]:

```
Cd.symmetries()
```

Actually, Cd is also antisymmetric with respect to the first two indices (positions 0 and 1), as we can check:

In [33]:

```
Cd == Cd.antisymmetrize(0,1)
```

Out[33]:

To take this symmetry into account explicitely, we set

In [34]:

```
Cd = Cd.antisymmetrize(0,1)
```

Hence we have now

In [35]:

```
Cd.symmetries()
```

The Simon-Mars tensor with respect to the Killing vector $\xi$ is a rank-3 tensor introduced by Marc Mars in 1999 (Class. Quantum Grav. **16**, 2507). It has the remarkable property to vanish identically if, and only if, the spacetime $(\mathcal{M},g)$ is locally isometric to a Kerr spacetime.

Let us evaluate the Simon-Mars tensor by following the formulas given in Mars' article. The starting point is the self-dual complex 2-form associated with the Killing 2-form $F$, i.e. the object $\mathcal{F} := F + i \, {}^* F$, where ${}^*F$ is the Hodge dual of $F$:

In [36]:

```
FF = F + I * F.hodge_dual(g)
FF.set_name('FF', r'\mathcal{F}') ; print(FF)
```

In [37]:

```
FF.display()
```

Out[37]:

Let us check that $\mathcal{F}$ is self-dual, i.e. that it obeys ${}^* \mathcal{F} = -i \mathcal{F}$:

In [38]:

```
FF.hodge_dual(g) == - I * FF
```

Out[38]:

Let us form the right self-dual of the Weyl tensor as follows $$\mathcal{C}_{\alpha\beta\mu\nu} = C_{\alpha\beta\mu\nu} + \frac{i}{2} \epsilon^{\rho\sigma}_{\ \ \ \mu\nu} \, C_{\alpha\beta\rho\sigma},$$ where $\epsilon^{\rho\sigma}_{\ \ \ \mu\nu}$ is associated to the Levi-Civita tensor $\epsilon_{\rho\sigma\mu\nu}$ and is obtained by

In [39]:

```
eps = g.volume_form(2) # 2 = the first 2 indices are contravariant
print(eps)
eps.symmetries()
```

The right self-dual Weyl tensor is then

In [40]:

```
CC = Cd + I/2*( eps['^rs_..']*Cd['_..rs'] )
CC.set_name('CC', r'\mathcal{C}') ; print(CC)
```

In [41]:

```
CC.symmetries()
```

In [42]:

```
CC[0,1,2,3]
```

Out[42]:

The Ernst 1-form $\sigma_\alpha = 2 \mathcal{F}_{\mu\alpha} \, \xi^\mu$ (0 = contraction on the first index of $\mathcal{F}$):

In [43]:

```
sigma = 2*FF.contract(0, xi)
```

Instead of invoking the function contract(), we could have used the index notation to denote the contraction:

In [44]:

```
sigma == 2*( FF['_ma']*xi['^m'] )
```

Out[44]:

In [45]:

```
sigma.set_name('sigma', r'\sigma') ; print(sigma)
sigma.display()
```

Out[45]:

The symmetric bilinear form $\gamma = \lambda \, g + \underline{\xi}\otimes\underline{\xi}$:

In [46]:

```
gamma = lamb*g + xi_form * xi_form
gamma.set_name('gamma', r'\gamma') ; print(gamma)
gamma.display()
```

Out[46]:

First we evaluate $$ S^{(1)}_{\alpha\beta\gamma} = 4 \mathcal{C}_{\mu\alpha\nu\beta} \, \xi^\mu \, \xi^\nu \, \sigma_\gamma $$

In [47]:

```
S1 = 4*( CC.contract(0,xi).contract(1,xi) ) * sigma
print(S1)
```

Then we form the tensor $$ S^{(2)}_{\alpha\beta\gamma} = - \gamma_{\alpha\beta} \, \mathcal{C}_{\rho\gamma\mu\nu} \, \xi^\rho \, \mathcal{F}^{\mu\nu} $$ by first computing $\mathcal{C}_{\rho\gamma\mu\nu} \, \xi^\rho$:

In [48]:

```
xiCC = CC['_.r..']*xi['^r']
print(xiCC)
```

We use the index notation to perform the double contraction $\mathcal{C}_{\gamma\rho\mu\nu} \mathcal{F}^{\mu\nu}$:

In [49]:

```
FFuu = FF.up(g)
```

In [50]:

```
S2 = gamma * ( xiCC['_.mn']*FFuu['^mn'] )
print(S2)
S2.symmetries()
```

The Simon-Mars tensor with respect to $\xi$ is obtained by antisymmetrizing $S^{(1)}$ and $S^{(2)}$ on their last two indices and adding them: $$ S_{\alpha\beta\gamma} = S^{(1)}_{\alpha[\beta\gamma]} + S^{(2)}_{\alpha[\beta\gamma]} $$ We use the index notation for the antisymmetrization:

In [51]:

```
S1A = S1['_a[bc]']
S2A = S2['_a[bc]']
```

An equivalent writing would have been (the last two indices being in position 1 and 2):

In [52]:

```
# S1A = S1.antisymmetrize(1,2)
# S2A = S2.antisymmetrize(1,2)
```

The Simon-Mars tensor is

In [53]:

```
S = S1A + S2A
S.set_name('S') ; print(S)
S.symmetries()
```

In [54]:

```
S.display()
```

Out[54]:

**We thus recover the fact that the Simon-Mars tensor vanishes identically in Kerr spacetime.**

To check that the above computation was not trival, here is the component 112=$rr\theta$ for each of the two parts of the Simon-Mars tensor:

In [55]:

```
S1A[1,1,2]
```

Out[55]:

In [56]:

```
S2A[1,1,2]
```

Out[56]:

In [57]:

```
S1A[1,1,2] + S2A[1,1,2]
```

Out[57]: