Tensor calculus with open-source software:

the SageManifolds project

Eric Gourgoulhon1 , Michal Bejger2 , Marco Mancini1
arXiv:1412.4765v2 [gr-qc] 21 Dec 2014

1
Laboratoire Univers et Théories, UMR 8102 du CNRS, Observatoire de Paris, Université
Paris Diderot, 92190 Meudon, France
2
Centrum Astronomiczne im. M. Kopernika, ul. Bartycka 18, 00-716 Warsaw, Poland
E-mail: [email protected], [email protected], [email protected]

Abstract. The SageManifolds project aims at extending the mathematics software system
Sage towards differential geometry and tensor calculus. Like Sage, SageManifolds is free, open-
source and is based on the Python programming language. We discuss here some details of
the implementation, which relies on Sage’s parent/element framework, and present a concrete
example of use.

1. Introduction
Computer algebra for general relativity (GR) has a long history, which started almost as soon as
computer algebra itself in the 1960s. The first GR program was GEOM, written by J.G. Fletcher
in 1965 [1]. Its main capability was to compute the Riemann tensor of a given metric. In 1969,
R.A. d’Inverno developed ALAM (for Atlas Lisp Algebraic Manipulator ) and used it to compute
the Riemann and Ricci tensors of the Bondi metric. According to [2], the original calculations
took Bondi and collaborators 6 months to finish, while the computation with ALAM took 4
minutes and yielded the discovery of 6 errors in the original paper. Since then, numerous
packages have been developed: the reader is referred to [3] for a review of computer algebra
systems for GR prior to 2002, and to [4] for a more recent review focused on tensor calculus.
It is also worth to point out the extensive list of tensor calculus packages maintained by J. M.
Martin-Garcia at [5].

2. Software for differential geometry

Software packages for differential geometry and tensor calculus can be classified in two categories:
(i) Applications atop some general purpose computer algebra system. Notable examples are
the xAct suite [6] and Ricci [7], both running atop Mathematica, DifferentialGeometry [8]
integrated into Maple, GRTensorII [9] atop Maple and Atlas 2 [10] for Mathematica and
Maple.
(ii) Standalone applications. Recent examples are Cadabra (field theory) [11], SnapPy (topology
and geometry of 3-manifolds) [12] and Redberry (tensors) [13].
All applications listed in the second category are free software. In the first category, xAct and
Ricci are also free software, but they require a proprietary product, the source code of which is
closed (Mathematica).
 As far as tensor calculus is concerned, the above packages can be distinguished by the type of
computation that they perform: abstract calculus (xAct/xTensor, Ricci, Cadabra, Redberry), or
component calculus (xAct/xCoba, DifferentialGeometry, GRTensorII, Atlas 2). In the first category,
tensor operations such as contraction or covariant differentiation are performed by manipulating
the indices themselves rather than the components to which they correspond. In the second
category, vector frames are explicitly introduced on the manifold and tensor operations are
carried out on the components in a given frame.

3. An overview of Sage
Sage [14] is a free, open-source mathematics software system, which is based on the Python
programming language. It makes use of over 90 open-source packages, among which are Maxima
and Pynac (symbolic calculations), GAP (group theory), PARI/GP (number theory), Singular
(polynomial computations), and matplotlib (high quality 2D figures). Sage provides a uniform
Python interface to all these packages; however, Sage is much more than a mere interface: it
contains a large and increasing part of original code (more than 750,000 lines of Python and
Cython, involving 5344 classes). Sage was created in 2005 by W. Stein [15] and since then its
development has been sustained by more than a hundred researchers (mostly mathematicians).
Very good introductory textbooks about Sage are [16, 17, 18].
Apart from the syntax, which is based on a popular programming language and not a custom
script language, a difference between Sage and, e.g., Maple or Mathematica is the usage of
the parent/element pattern. This framework more closely reflects actual mathematics. For
instance, in Mathematica, all objects are trees of symbols and the program is essentially a set
of sophisticated rules to manipulate symbols. On the contrary, in Sage each object has a given
type (i.e. is an instance of a given Python class1 ), and one distinguishes parent types, which
model mathematical sets with some structure (e.g. algebraic structure), from element types,
which model set elements. Moreover, each parent belongs to some dynamically generated class
that encodes informations about its category, in the mathematical sense of the word (see [19] for
a discussion of Sage’s category framework). Automatic conversion rules, called coercions, prior
to a binary operation, e.g. x + y with x and y having different parents, are implemented.

4. The SageManifolds project

4.1. Aim and scope
Sage is well developed in many areas of mathematics but very little exists for differential geometry
and tensor calculus. One may mention differential forms defined on a fixed coordinate patch,
implemented by J. Vankerschaver [20], and the 2-dimensional parametrized surfaces of the 3-
dimensional Euclidean space recently added by M. Malakhaltsev and J. Vankerschaver [21].
The aim of SageManifolds [22] is to introduce smooth manifolds and tensor fields in Sage,
with the following requirements: (i) one should be able to introduce various coordinate charts
on a manifold, with the relevant transition maps; (ii) tensor fields must be manipulated as such
and not through their components with respect to a specific (possibly coordinate) vector frame.
Concretely, the project amounts to creating new Python classes, such as Manifold, Chart,
TensorField or Metric, to implement them within the parent/element pattern and to code
mathematical operations as class methods. For instance the class Manifold, devoted to real
smooth manifolds, is a parent class, i.e. it inherits from Sage’s class Parent. On the other hand,
the class devoted to manifold points, ManifoldPoint, is an element class and therefore inherits
from Sage’s class Element. This is illustrated by the inheritance diagram of Fig. 1. In this
1
Let us recall that within an object-oriented programming language (as Python), a class is a structure to declare
and store the properties common to a set of objects. These properties are data (called attributes or state variables)
and functions acting on the data (called methods). A specific realization of an object within a given class is called
an instance of that class.
 UniqueRepresentation Parent Element

category: Sets
ManifoldSubset
element: ManifoldPoint
ManifoldPoint

Native Sage class ManifoldOpenSubset

SageManifolds class
(differential part)
Manifold

Submanifold RealLine

Figure 1. Python classes for smooth manifolds (Manifold), generic subsets of

them (ManifoldSubset), open subsets of them (ManifoldOpenSubset) and points on them
(ManifoldPoint).

diagram, each class at the base of some arrow is a subclass (also called derived class) of the class
at the arrowhead. Note however that the actual type of a parent is a dynamically generated class
taking into account the mathematical category to which it belongs. For instance, the actual type
of a smooth manifold is not Manifold, but a subclass of it named Manifold with category,
reflecting the fact that Manifold is declared in the category of Sets2 . Note also that the
class Manifold inherits from Sage’s class UniqueRepresentation, which ensures that there is a
unique manifold instance for a given dimension and given name.

4.2. Implementation of charts

Given a smooth manifold M of dimension n, a coordinate chart on some open subset U ⊂ M
is implemented in SageManifolds via the class Chart, whose main data is a n-tuple of Sage
symbolic variables (x1 , . . . , xn ), each of them representing a coordinate. In general, more than
one (regular) chart is required to cover the entire manifold. For instance, at least 2 charts are
necessary for the n-dimensional sphere Sn (n ≥ 1) and the torus T2 and 3 charts for the real
projective plane RP2 (see Fig. 6 below). Accordingly, SageManifolds allows for an arbitrary
number of charts. To fully specify the manifold, one shall also provide the transition maps
(changes of coordinates) on overlapping chart domains (SageManifolds class CoordChange).

4.3. Implementation of scalar fields

A scalar field on manifold M is a smooth mapping

f : U ⊂ M −→ R
(1)
p 7−→ f (p),
2
A tighter category would be topological spaces, but such a category has been not implemented in Sage yet.
 UniqueRepresentation Parent CommutativeAlgebraElement

category: CommutativeAlgebras
ScalarFieldAlgebra ScalarField
ring: SR
parent: ScalarFieldAlgebra
element: ScalarField

ZeroScalarField
Native Sage class
parent: ScalarFieldAlgebra
SageManifolds class
(differential part)

Figure 2. Python classes for scalar fields on a manifold.

where U is some open subset of M. A scalar field has different coordinate representations F ,
F̂ , etc. in different charts X, X̂, etc. defined on U :

f (p) = F ( x1 , . . . , xn ) = F̂ ( x̂1 , . . . , x̂n ) = . . . (2)

| {z } | {z }
coord. of p coord. of p
in chart X in chart X̂
These representations are stored in some attribute of the class ScalarField, namely a Python
dictionary3 whose keys are the various charts defined on U :
n o
f. express = X : F, X̂ : F̂ , . . . . (3)

Each representation F is an instance of the class FunctionChart, which resembles Sage native
symbolic functions, but involves automatic simplifications in all arithmetic operations.
Given an open subset U ⊂ M, the set C ∞ (U ) of scalar fields defined on U has naturally the
structure of a commutative algebra over R: it is clearly a vector space over R and it is endowed
with a commutative ring structure by pointwise multiplication:

∀f, g ∈ C ∞ (U ), ∀p ∈ U, (f.g)(p) := f (p)g(p). (4)

The algebra C ∞ (U ) is implemented in SageManifolds via the parent class ScalarFieldAlgebra,

in the category CommutativeAlgebras. The corresponding element class is of course
ScalarField (cf. Fig. 2).

4.4. Modules and free modules

Given an open subset U ⊂ M, the set X (U ) of all smooth vector fields defined on U has
naturally the structure of a module over the algebra C ∞ (U ). Let us recall that a module is
similar to a vector space, except that it is based on a ring (here C ∞ (U )) instead of a field
(usually R or C in physical applications). Of course, every vector space is a module, since every
3
A dictionary, also known as associative array, is a data structure that generalizes the concept of array in the
sense that the key to access to some element is not restricted to an integer or a tuple of integers.
field is a ring. There is an important difference though: every vector space has a basis (as a
consequence of the axiom of choice), while a module does not necessarily have any. When it
possesses one, it is called a free module. Moreover, if the module’s base ring is commutative, it
can be shown that all bases have the same cardinality, which is called the rank of the module
(for vector spaces, which are free modules, the word dimension is used instead of rank ).
If X (U ) is a free module (examples are provided in Sec. 4.5 below), a basis of it is nothing
but a vector frame (ea )1≤a≤n on U (often called a tetrad in the context of 4-dimensional GR):

∀v ∈ X (U ), v = v a ea , with v a ∈ C ∞ (U ). (5)

The rank of X (U ) is thus n, i.e. the manifold’s dimension4 . At any point p ∈ U , Eq. (5) gives
birth to an identity in the tangent vector space Tp M:

v(p) = v a (p) ea (p), with v a (p) ∈ R, (6)

which means that the set (ea (p))1≤a≤n is a basis of Tp M. Note that if U is covered by a chart
(xa )1≤a≤n , then (∂/∂xa )1≤a≤n is a vector frame on U , usually called coordinate frame or natural
basis. Note also that, being a vector space over R, the tangent space Tp M represents another
kind of free module which occurs naturally in the current context.
It turns out that so far only free modules with a distinguished basis were implemented in
Sage. This means that, given a free module M of rank n, all calculations refer to a single basis
of M . This amounts to identifying M with Rn , where R is the ring over which M is based. This
is unfortunately not sufficient for dealing with smooth manifolds in a coordinate-independent
way. For instance, there is no canonical isomorphism between Tp M and Rn when no coordinate
system is privileged in the neighborhood of p. Therefore we have started a pure algebraic part
of SageManifolds to implement generic free modules, with an arbitrary number of bases, none of
them being distinguished. This resulted in (i) the parent class FiniteRankFreeModule, within
Sage’s category Modules, and (ii) the element class FiniteRankFreeModuleElement. Then both
classes VectorFieldFreeModule (for X (U ), when it is a free module) and TangentSpace (for
Tp M) inherit from FiniteRankFreeModule (see Fig. 3).

4.5. Implementation of vector fields

Ultimately, in SageManifolds, vector fields are described by their components with respect to
various vector frames, according to Eq. (5), but without any vector frame being privileged,
leaving the freedom to select one to the user, as well as to change coordinates. A key point is
that not every manifold admits a global vector frame. A manifold M, or more generally an open
subset U ⊂ M, that admits a global vector frame is called parallelizable. Equivalently, M is
parallelizable if, and only if, X (M) is a free module. In terms of tangent bundles, parallelizable
manifolds are those for which the tangent bundle is trivial: T M ' M × Rn . Examples of
parallelizable manifolds are [23]
• the Cartesian space Rn for n = 1, 2, . . .,
• the circle S1 ,
• the torus T2 = S1 × S1 ,
• the sphere S3 ' SU(2), as any Lie group,
• the sphere S7 ,
• any orientable 3-manifold (Steenrod theorem [24]).
4
Note that the dimensionality of X (U ) depends of the adopted structure: as a vector space over R, the dimension
of X (U ) is infinite, while as a free module over C ∞ (U ), X (U ) has a finite rank. Note also that if X (U ) is not
free (i.e. no global vector frame exists on U ), the notion of rank is meaningless.
 UniqueRepresentation Parent

les

ca
du

te
go
Mo

r
y:
s
ule

M
:
od

gory

od
:M

ul
y

cate
or

es
a teg
c
TensorFieldModule VectorFieldModule FiniteRankFreeModule
ring: ScalarFieldAlgebra ring: ScalarFieldAlgebra ring: CommutativeRing
element: TensorField element: VectorField element: FiniteRankFreeModuleElement

TangentSpace
VectorFieldFreeModule TensorFreeModule
ring: SR
Native Sage class ring: ScalarFieldAlgebra element:
element:
element: VectorFieldParal FreeModuleTensor
SageManifolds class TangentVector
(algebraic part)
SageManifolds class TensorFieldFreeModule
(differential part) ring: ScalarFieldAlgebra
element: TensorFieldParal

Figure 3. Python classes for modules. For each of them, the class of the base ring is indicated,
as well as the class for the elements.

On the other hand, examples of non-parallelizable manifolds are

• the sphere S2 (as a consequence of the hairy ball theorem), as well as any sphere Sn with
n 6∈ {1, 3, 7},
• the real projective plane RP2 .
Actually, “most” manifolds are non-parallelizable. As noticed above, if a manifold is covered by
a single chart, it is parallelizable (the prototype being Rn ). But the reverse is not true: S1 and
T2 are parallelizable and require at least two charts to cover them.
If the manifold M is not parallelizable, we assume that it can be covered by a finite number
N of parallelizable open subsets Ui (1 ≤ i ≤ N ). In particular, this holds if M is compact, for
any compact manifold admits a finite atlas. We then consider the restrictions of vector fields
to the Ui ’s. For each i, X (Ui ) is a free module of rank n = dim M and is implemented in
SageManifolds as an instance of VectorFieldFreeModule (cf. Sec. 4.4 and Figs. 3 and 4). Each
vector field v ∈ X (Ui ) has different sets of components (v a )1≤a≤n in different vector frames
(ea )1≤a≤n introduced on Ui [cf. Eq. (5)]. They are stored as a Python dictionary whose keys
are the vector frames:

v. components = {(e) : (v a ), (ê) : (v̂ a ), . . .} . (7)

4.6. Implementation of tensor fields

The implementation of tensor fields in SageManifolds follows the strategy adopted for vector
fields. Consider for instance a tensor field T of type (1,1) on the manifold M. It can
 Element

ModuleElement
parent: Module

TensorField FreeModuleTensor
parent: parent:
TensorFieldModule TensorFreeModule

VectorField TensorFieldParal FiniteRankFreeModuleElement

parent: parent: parent:
VectorFieldModule TensorFieldFreeModule FiniteRankFreeModule

VectorFieldParal TangentVector
Native Sage class parent: parent:
SageManifolds class VectorFieldFreeModule TangentSpace
(algebraic part)
SageManifolds class
(differential part)

Figure 4. Python classes implementing tensors and tensor fields.

be represented by components T ab only on a parallelizable open subset U ⊂ M, since the

decomposition
T |U = T ab ea ⊗ eb , (8)
which defines T ab , is meaningful only when a vector frame (ea ) exists5 . Therefore, one first
decomposes the tensor field T into its restrictions T |Ui on parallelizable open subsets of M,
Ui (1 ≤ i ≤ N ) and then considers the components on various vector frames on each subset
Ui . For each vector frame (ea ), the set of components (T ab ) is stored in a devoted class (named
Components), which takes into account all the tensor monoterm symmetries: only non-redundant
components are stored, the other ones being deduced by (anti)symmetry. This is illustrated in
Fig. 5, which depicts the internal storage of tensor fields in SageManifolds. Note that each
component T ab is a scalar field on Ui , according to the formula

T ab = T (ea , eb ). (9)

Accordingly, the penultimate level of Fig. 5 corresponds to the scalar field storage, as described
by (3). The last level is constituted by Sage’s symbolic expressions (class Expression).

5. Current status of SageManifolds

5.1. Functionalities
At present (version 0.6), the functionalities included in SageManifolds are as follows:
5
Using standard notation, in Eq. (8), (eb ) stands for the coframe dual to (ea )
 TensorField
T

dictionary TensorField. restrictions

domain 1: TensorFieldParal domain 2: TensorFieldParal ...
U1 T |U1 = T ab ea ⊗ eb = T âb̂ εâ ⊗ εb̂ = . . . U2 T |U2

dictionary TensorFieldParal. components

frame 1: Components frame 2: Components ...

(ea ) (T ab )1≤a, b ≤n (εâ ) (T âb̂ )1≤â, b̂ ≤n

dictionary Components. comp

ScalarField ScalarField
(1, 1) : T 11 (1, 2) : T 12
...

dictionary ScalarField. express

chart 1: FunctionChart chart 2: FunctionChart ...

T 11 x1 , . . . , xn T 11 y 1 , . . . , y n



(xa ) (y a )

Expression Expression
x1 cos x2 y 1 + y 2 cos y 1 − y 2

Figure 5. Storage of tensor fields in SageManifolds. Each red box represents a Python
dictionary; the dictionary values are depicted by yellow boxes, the keys being indicated at the
left of each box.

• maps between manifolds and pullback operator,

• submanifolds and pushforward operator,
• standard tensor calculus (tensor product, contraction, symmetrization, etc.), even on non-
parallelizable manifolds,
• arbitrary monoterm tensor symmetries,
• exterior calculus (wedge product and exterior derivative, Hodge duality),
• Lie derivatives along a vector field,
• affine connections (curvature, torsion),
• pseudo-Riemannian metrics (Levi-Civita connection, Weyl tensor),
• graphical display of charts.

5.2. Parallelization
To improve the reactivity of SageManifolds and take advantage of multicore processors, some
tensorial operations are performed by parallel processes. The parallelization is implemented
by means of the Python library multiprocessing, via the built-in Sage decorator @parallel.
Using it permits to define a function that is run on different sub-processes. If n processes are
used, given a function and a list of arguments for it, any process will call the function with an
element of the list, one at time, spanning all the list.
Currently6 , the parallelized operations are tensor algebra, tensor contractions, computation
of the connection coefficient and computation of Riemann tensor.
The parallelization of an operation is achieved by first creating a function which computes
the required operation on a subset of the components of a tensor; second, by creating a list of 2n
(twice the number of used processes) arguments for this function. Then applying this function
to the input list, the calculation is performed in parallel. At the end of the computation a fourth
phase is needed to retrieve the results. The choice to divide the work in 2n is a compromise
between the load balancing and the cost of creating multiple processes. The number of processors
to be used in the parallelization can be controlled by the user.

6. SageManifolds at work: Kerr spacetime and Simon-Mars tensor

We give hereafter a short illustration of SageManifolds focused on tensor calculus in 4-dimensional
GR. Another example, to be found at [25], is based on the manifold S2 and focuses more on the
use of multiple charts and on the treatment of non-parallelizable manifolds. Yet another example
illustrates some graphical capabilities of SageManifolds: Figure 6 shows the famous immersion of
the real projective plane RP2 into the Euclidean space R3 known as the Boy surface. This figure
has been obtained by means of the method plot() applied to three coordinate charts covering
RP2 , the definition of which is related to the interpretation of RP2 as the set of straight lines ∆
through the origin of R3 : (i) in red, the chart X1 covering the open subset of RP2 defined by
all lines ∆ that are not parallel to the plane z = 0, the coordinates of X1 being the coordinates
(x, y) of the intersection of the considered line ∆ with the plane z = 1; (ii) in green, the chart
X2 covering the open subset defined by all lines ∆ that are not parallel to the plane x = 0, the
coordinates of X2 being the coordinates (y, z) of intersection with the plane x = 1; (iii) in blue,
the chart X3 covering the open subset defined by all lines ∆ that are not parallel to the plane
y = 0, the coordinates of X2 being the coordinates (z, x) of intersection with the plane y = 1.
Figure 6 actually shows the coordinate grids of these three charts through the Apéry map [26],
which realizes an immersion of RP2 into R3 . This example, as many others, can be found at
[25].
Let us consider a 4-dimensional spacetime, i.e. a smooth 4-manifold M endowed with a
Lorentzian metric g. We assume that (M, g) is stationary and denote by ξ the corresponding
Killing vector field. The Simon-Mars tensor w.r.t. ξ is then the type-(0,3) tensor field S defined
by [27]
Sαβγ := 4Cµαν[β ξ µ ξ ν σγ] + γα[β Cγ]ρµν ξ ρ F µν , (10)
where
• γαβ := λ gαβ + ξα ξβ , with λ := −ξµ ξ µ ;
• Cαβµν := Cαβµν + 2i ρσµν Cαβρσ , with C αβµν being the Weyl curvature tensor and αβµν the
Levi-Civita volume 4-form;
• Fαβ := Fαβ + i ∗Fαβ , with Fαβ := ∇α ξβ (Killing 2-form) and ∗Fαβ := 12 µναβ Fµν ;
• σα := 2Fµα ξ µ (Ernst 1-form).
The Simon-Mars tensor provides a nice characterization of Kerr spacetime, according the
following theorem proved by Mars [27]: if g satisfies the vacuum Einstein equation and (M, g)
contains a stationary asymptotically flat end M∞ such that ξ tends to a time translation at
infinity in M∞ and the Komar mass of ξ in M∞ is non-zero, then S = 0 if, and only if, (M, g)
is locally isometric to a Kerr spacetime.
6
in the development version of SageManifolds; this will become available in version 0.7 of the stable release.
Figure 6. Boy surface depicted via the grids of 3 coordinate charts covering RP2 (see the text
for the color code).

In what follows, we use SageManifolds to compute the Simon-Mars tensor according to formula
(10) for the Kerr metric and check that we get zero (the “if” part of the above theorem). The
corresponding worksheet can be downloaded from
http://sagemanifolds.obspm.fr/examples/html/SM_Simon-Mars_Kerr.html.
For the sake of clarity, let us recall that, as an object-oriented language, Python (and hence
Sage) makes use of the following postfix notation:
result = object.function(arguments)
In a functional language, this would correspond to result = function(object,arguments).
For instance, the Riemann tensor of a metric g is obtained as riem = g.riemann() (in this case,
there is no extra argument, hence the empty parentheses). With this in mind, let us proceed
with the computation by means of SageManifolds. In the text below, the blue color denotes the
outputs as they appear in the Sage notebook (note that all outputs are automatically LATEX-
formatted by Sage).
The first step is to declare the Kerr spacetime (or more precisely the part of the Kerr spacetime
covered by Boyer-Lindquist coordinates) as a 4-dimensional manifold:
M = Manifold(4, ’M’, latex_name=r’\mathcal{M}’)
print M
4-dimensional manifold ’M’

The standard Boyer-Lindquist coordinates (t, r, θ, φ) are introduced by declaring a chart X on

M, via the method chart(), the argument of which is a string expressing the coordinates names,
their ranges (the default is (−∞, +∞)) and their LATEX symbols:
X.<t,r,th,ph> = M.chart(’t r:(0,+oo) th:(0,pi):\\theta ph:(0,2*pi):\\phi’)
print X ; X
chart (M, (t, r, th, ph))
(M, (t, r, θ, φ))
We define next the Kerr metric g by setting its components in the coordinate frame associated
with Boyer-Lindquist coordinates. Since the latter is the current manifold’s default frame (being
the only one defined at this stage), we do not need to specify it when referring to the components
by their indices:
g = M.lorentz_metric(’g’)
m = var(’m’) ; a = var(’a’)
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.view()
! !
a2 cos (θ)2 − 2 mr + r2 2 amr sin (θ)2
g= − dt ⊗ dt + − dt ⊗ dφ +
a2 cos (θ)2 + r2 a2 cos (θ)2 + r2
! !
a2 cos (θ)2 + r2 
2 2 2
 2 amr sin (θ)2
dr ⊗ dr + a cos (θ) + r dθ ⊗ dθ + − dφ ⊗ dt +
a2 − 2 mr + r2 a2 cos (θ)2 + r2
   
2 a2 mr sin (θ)4 + a2 r2 + r4 + a4 + a2 r2 cos (θ)2 sin (θ)2


  dφ ⊗ dφ
a2 cos (θ)2 + r2
The Levi-Civita connection ∇ associated with g is obtained by the method connection():
nab = g.connection() ; print nab
Levi-Civita connection ’nabla g’ associated with the Lorentzian metric ’g’ on the 4-dimensional
manifold ’M’

As a check, we verify that the covariant derivative of g with respect to ∇ vanishes identically:
nab(g).view()
∇g g = 0

As mentionned above, the default vector frame on the spacetime manifold is the coordinate basis
associated with Boyer-Lindquist coordinates:
M.default_frame() is X.frame()
True

X.frame()
  
∂ ∂ ∂ ∂
M, ∂t , ∂r , ∂θ , ∂φ

Let us consider the first vector field of this frame:

xi = X.frame()[0] ; xi
∂
∂t

print xi
vector field ’d/dt’ on the 4-dimensional manifold ’M’

The 1-form associated to it by metric duality is

xi_form = xi.down(g)
xi_form.set_name(’xi_form’, r’\underline{\xi}’)
print xi_form ; xi_form.view()
1-form ’xi form’ on the 4-dimensional manifold ’M’
2
2 amr sin(θ)2
 2   
−2 mr+r2
ξ = − a cos(θ)
a2 cos(θ)2 +r2
dt + − a2 cos(θ)2 +r2
dφ

Its covariant derivative is

nab_xi = nab(xi_form)
print nab_xi ; nab_xi.view()
tensor field ’nabla g xi form’ of type (0,2) on the 4-dimensional manifold ’M’
a2 m cos(θ)2 −mr2
   
2 a2 mr cos(θ) sin(θ)
∇g ξ = a4 cos(θ) 4 2
+2 a2 r2 cos(θ) +r4
dt ⊗ dr + 4 2
a4 cos(θ) +2 a2 r2 cos(θ)+r4
dt ⊗ dθ+
 2 2
3 2
a2 m cos(θ)2 −mr2 (a m cos(θ) −amr ) sin(θ)
 
− a4 cos(θ) 4
+2 a2 r2 cos(θ)2 +r4
dr ⊗ dt + a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dr ⊗ dφ+
 
2 (a3 mr+amr3 ) cos(θ) sin(θ)
 
2 a2 mr cos(θ) sin(θ)
− a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dθ ⊗ dt + a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dθ ⊗ dφ+
   
(a3 m cos(θ)2 −amr2 ) sin(θ)2 2 (a3 mr+amr3 ) cos(θ) sin(θ)
− a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dφ ⊗ dr + − a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dφ ⊗ dθ

Let us check that the Killing equation is satisfied:

nab_xi.symmetrize().view()
0

Equivalently, we check that the Lie derivative of the metric along ξ vanishes:
g.lie_der(xi).view()
0

Thanks to Killing equation, ∇ξ is antisymmetric. We may therefore define a 2-form by

F := −∇ξ. Here we enforce the antisymmetry by calling the method antisymmetrize()
on nab xi:
F = - nab_xi.antisymmetrize()
F.set_name(’F’)
print F ; F.view()
2-form ’F’ on the 4-dimensional manifold ’M’
a2 m cos(θ)2 −mr2
   
2 a2 mr cos(θ) sin(θ)
F = − a4 cos(θ) 4 2 2 2
+2 a r cos(θ)+r 4
dt ∧ dr + − 4 4 2 2
a cos(θ) +2 a r cos(θ) +r2 4
dt ∧ dθ+
 2 2
 
3 2 3 3
(a m cos(θ) −amr ) sin(θ) 2 (a mr+amr ) cos(θ) sin(θ)
− a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dr ∧ dφ + − a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dθ ∧ dφ

The squared norm of the Killing vector is

lamb = - g(xi,xi)
lamb.set_name(’lambda’, r’\lambda’)
print lamb ; lamb.view()
scalar field ’lambda’ on the 4-dimensional manifold ’M’
λ: M −→ R
a2 cos(θ)2 −2 mr+r2
(t, r, θ, φ) 7−→ a2 cos(θ)2 +r2

Instead of invoking g(ξ, ξ), we could have evaluated λ by means of the 1-form ξ acting on the
vector field ξ:
lamb == - xi_form(xi)
True

or, using index notation as λ = −ξa ξ a :

lamb == - ( xi_form[’_a’]*xi[’^a’] )
True

The Riemann curvature tensor associated with g is

Riem = g.riemann()
print Riem
tensor field ’Riem(g)’ of type (1,3) on the 4-dimensional manifold ’M’

The component R0 123 = Rt rθφ is

Riem[0,1,2,3]
(a7 m−2 a5 m2 r+a5 mr2 ) cos(θ) sin(θ)5 +(a7 m+2 a5 m2 r+6 a5 mr2 −6 a3 m2 r3 +5 a3 mr4 ) cos(θ) sin(θ)3
− a2 r6 −2 mr7 +r8 +(a8 −2 a6 mr+a6 r2 ) cos(θ)6 +3 (a6 r2 −2 a4 mr3 +a4 r4 ) cos(θ)4 +3 (a4 r4 −2 a2 mr5 +a2 r6 ) cos(θ)2
2 (a7 m−a5 mr2 −5 a3 mr4 −3 amr6 ) cos(θ) sin(θ)
+ a2 r6 −2 mr7 +r8 +(a8 −2 a6 mr+a6 r2 ) cos(θ)6 +3 (a6 r2 −2 a4 mr3 +a4 r4 ) cos(θ)4 +3 (a4 r4 −2 a2 mr5 +a2 r6 ) cos(θ)2

Let us check that the Kerr metric is a vacuum solution of Einstein equation, i.e. that the Ricci
tensor vanishes identically:
g.ricci().view()
Ric(g) = 0

The Weyl conformal curvature tensor is

C = g.weyl() ; print C
tensor field ’C(g)’ of type (1,3) on the 4-dimensional manifold ’M’

Let us exhibit the component C 0101 = C t rtr :

C[0,1,0,1]
3 a4 mr cos(θ)4 +3 a2 mr3 +2 mr5 −(9 a4 mr+7 a2 mr3 ) cos(θ)2
a2 r6 −2 mr7 +r8 +(a8 −2 a6 mr+a6 r2 ) cos(θ)6 +3 (a6 r2 −2 a4 mr3 +a4 r4 ) cos(θ)4 +3 (a4 r4 −2 a2 mr5 +a2 r6 ) cos(θ)2

To form the Simon-Mars tensor, we need the fully covariant form (type-(0,4) tensor) of the Weyl
tensor (i.e. Cαβµν = gασ C σβµν ); we get it by lowering the first index with the metric:
Cd = C.down(g) ; print Cd
tensor field of type (0,4) on the 4-dimensional manifold ’M’

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):
Cd.symmetries()
no symmetry; antisymmetry: (2, 3)

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

To take this symmetry into account explicitly, we set

Cd = Cd.antisymmetrize(0,1)
Cd.symmetries()
no symmetry; antisymmetries: [(0, 1), (2, 3)]

The starting point in the evaluation of Simon-Mars tensor is the self-dual complex 2-form
associated with the Killing 2-form F , i.e. the object F := F + i ∗ F , where ∗ F is the Hodge
dual of F :
FF = F + I * F.hodge_star(g)
FF.set_name(’FF’, r’\mathcal{F}’)
print FF ; FF.view()
2-form
 ’FF’ on the 4-dimensional
 manifold’M’ 
2
cos(θ)2 +2i amr cos(θ)−mr 2 (i a3 m cos(θ)2 −2 a2 mr cos(θ)−i amr2 ) sin(θ)
F = − a am4 cos(θ) 4
+2 a2 r 2 cos(θ)2 +r 4
dt ∧ dr + a4 cos(θ)4 +2 a2 r 2 cos(θ)2 +r 4
dt ∧ dθ

−4i a4 m2 r 2 cos(θ) sin(θ)4 +(a3 mr 4 −2 am2 r 5 +amr 6 −(a7 m−2 a5 m2 r+a5 mr 2 ) cos(θ)4 ) sin(θ)2
+ a2 r6 −2 mr7 +r8 +(a8 −2 a6 mr+a6 r2 ) cos(θ)6 +3 (a6 r2 −2 a4 mr3 +a4 r4 ) cos(θ)4 +3 (a4 r4 −2 a2 mr5 +a2 r6 ) cos(θ)2

((2i a6 mr+2i a4 mr3 ) cos(θ)3 +(−4i a4 m2 r2 +2i a4 mr3 −4i a2 m2 r4 +2i a2 mr5 ) cos(θ)) sin(θ)2
− a2 r6 −2 mr7 +r8 +(a8 −2 a6 mr+a6 r2 ) cos(θ)6 +3 (a6 r2 −2 a4 mr3 +a4 r4 ) cos(θ)4 +3 (a4 r4 −2 a2 mr5 +a2 r6 ) cos(θ)2 dr ∧ dφ
 
(i a4 m+i a2 mr2 ) sin(θ)3 +(−i a4 m+i mr4 +2 (a3 mr+amr3 ) cos(θ)) sin(θ)
+ − 4 2
a4 cos(θ) +2 a2 r 2 cos(θ) +r 4
dθ ∧ dφ

Let us check that F is self-dual, i.e. that it obeys ∗ F = −iF :

FF.hodge_star(g) == - I * FF
True

To evaluate the right self-dual of the Weyl tensor, we need the tensor αβ γδ :
eps = g.volume_form(2) # 2 = the first 2 indices are contravariant
print eps ; eps.symmetries()
tensor field of type (2,2) on the 4-dimensional manifold ’M’
no symmetry; antisymmetries: [(0, 1), (2, 3)]

The right self-dual Weyl tensor is then:

CC = Cd + I/2*( eps[’^rs_..’]*Cd[’_..rs’] )
CC.set_name(’CC’, r’\mathcal{C}’) ;
print CC ; CC.symmetries()
tensor field ’CC’ of type (0,4) on the 4-dimensional manifold ’M’
no symmetry; antisymmetries: [(0, 1), (2, 3)]

CC[0,1,2,3]
(a5 m cos(θ)5 +3i a4 mr cos(θ)4 +3i a2 mr3 +2i mr5 −(3 a5 m+5 a3 mr2 ) cos(θ)3 ) sin(θ)
a6 cos(θ)6 +3 a4 r2 cos(θ)4 +3 a2 r4 cos(θ)2 +r6
4 mr−7i a2 mr 3 cos(θ)2 +3 3 a3 mr 2 +2 amr 4 cos(θ) sin(θ)
((−9i a ) ( ) )
+ a6 cos(θ)6 +3 a4 r2 cos(θ)4 +3 a2 r4 cos(θ)2 +r6

The Ernst 1-form σα = 2Fµα ξ µ (0 = contraction on the first index of F ):

sigma = 2*FF.contract(0, xi)
Instead of invoking the method contract(), we could have used the index notation to denote
the contraction:
sigma == 2*( FF[’_ma’]*xi[’^m’] )
True

sigma.set_name(’sigma’, r’\sigma’)
print sigma ; sigma.view()
1-form ’sigma’ on the 4-dimensional manifold  ’M’ 
2 a2 m cos(θ)2 +4i amr cos(θ)−2 mr2 (2i a3 m cos(θ)2 −4 a2 mr cos(θ)−2i amr2 ) sin(θ)
 
σ = − a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4 dr + a4 cos(θ)4 +2 a2 r2 cos(θ)2 +r4
dθ

The symmetric bilinear form γ = λ g + ξ ⊗ ξ:

gamma = lamb*g + xi_form * xi_form
gamma.set_name(’gamma’, r’\gamma’)
print gamma ; gamma.view()
field of symmetric bilinear forms ’gamma’ on the 4-dimensional manifold ’M’
a2 cos(θ)2 −2 mr+r2
  
2 2 2
γ= a2 −2 mr+r2
dr ⊗ dr + a cos (θ) − 2 mr + r dθ ⊗ dθ+
 
2 a2 mr sin(θ) −(2 a2 mr−a2 r2 +2 mr3 −r4 −(a4 +a2 r2 ) cos(θ)2 ) sin(θ)2
4

a2 cos(θ)2 +r2
dφ ⊗ dφ
(1)
The first part of the Simon-Mars tensor is Sαβγ = 4Cµανβ ξ µ ξ ν σγ :
S1 = 4*( CC.contract(0,xi).contract(1,xi) ) * sigma
print S1
tensor field of type (0,3) on the 4-dimensional manifold ’M’
(2)
The second part is Sαβγ = γαβ Cργµν ξ ρ F µν , which we compute using the index notation to
perform the contractions:
FFuu = FF.up(g)
xiCC = CC[’_.r..’]*xi[’^r’]
S2 = gamma * ( xiCC[’_.mn’]*FFuu[’^mn’] )
print S2
tensor field of type (0,3) on the 4-dimensional manifold ’M’

To get the Simon-Mars tensor, we need to antisymmetrize S (1) and S (2) on their last two indices;
we choose to use the standard index notation to perform this operation (an alternative would
have been to call directly the method antisymmetrize()):
S1A = S1[’_a[bc]’]
S2A = S2[’_a[bc]’]
The Simon-Mars tensor is then
S = = S1A + S2A
S.set_name(’S’)
print S ; S.symmetries()
tensor field ’S’ of type (0,3) on the 4-dimensional manifold ’M’
no symmetry; antisymmetry: (1, 2)

We check that it vanishes identically, as it should for Kerr spacetime:

S.view()
S=0

7. Conclusion and future prospects

SageManifolds is a work in progress. It encompasses currently ∼ 35, 000 lines of Python code
(including comments and doctests). The last stable version (0.6), the functionalities of which
are listed in Sec. 5.1, is freely downloadable from the project page [22]. The development version
(to become version 0.7 soon) is also available from that page. Among future developments are
• the extrinsic geometry of pseudo-Riemannian submanifolds,
• the computation of geodesics (numerical integration via Sage/GSL or Gyoto [28]),
• evaluating integrals on submanifolds,
• adding more graphical outputs,
• adding more functionalities: symplectic forms, fibre bundles, spinors, variational calculus,
etc.
• the connection with numerical relativity.
The last point means using SageManifolds for interactive exploration of numerically generated
spacetimes. Looking at the diagram in Fig. 5, one realizes that it suffices to replace only the
lowest level, currently relying on Sage’s symbolic expressions, by computations on numerical
data.
Let us conclude by stating that, in the very spirit of free software, anybody interested in
contributing to the project is very welcome!

Acknowledgments
This work has benefited from enlightening discussions with Volker Braun, Vincent Delecroix,
Simon King, Sébastien Labbé, José M. Martı́n-Garcı́a, Marc Mezzarobba, Thierry Monteil,
Travis Scrimshaw, Nicolas M. Thiéry and Anne Vaugon. We also thank Stéphane Méné for
his technical help and Tolga Birkandan for fruitful comments about the manuscript. EG
acknowledges the warm hospitality of the Organizers of the Encuentros Relativistas Españoles
2014, where this work was presented.

References
[1] Fletcher J G, Clemens R, Matzner R, Thorne K S and Zimmerman B A 1967 Astrophys. J. 148, L91
[2] Skea J E F 1994 Applications of SHEEP Lecture notes available at http://www.computeralgebra.nl/
systemsoverview/special/tensoranalysis/sheep/
[3] MacCallum M A H 2002 Int. J. Mod. Phys. A 17, 2707
[4] Korol’kova A V, Kulyabov D S and Sevast’yanov L A 2013 Prog. Comput. Soft. 39, 135
[5] http://www.xact.es/links.html
 [6] Martin-Garcia J M 2008 Comput. Phys. Commun. 179, 597; http://www.xact.es
[7] http://www.math.washington.edu/~lee/Ricci/
[8] Anderson I M and Torre C G 2012 J. Math. Phys. 53, 013511; http://digitalcommons.usu.edu/dg/
[9] http://grtensor.phy.queensu.ca/
[10] http://digi-area.com/Maple/atlas/
[11] Peeters K 2007 Comput. Phys. Commun. 15, 550; http://cadabra.phi-sci.com/
[12] Culler M, Dunfield N M and Weeks J R, SnapPy, a computer program for studying the geometry and topology
of 3-manifolds, http://snappy.computop.org
[13] Bolotin D A and Poslavsky S V 2013 Introduction to Redberry: the computer algebra system designed for
tensor manipulation Preprint arXiv:1302.1219; http://redberry.cc/
[14] http://sagemath.org/
[15] Stein W and Joyner D 2005 Commun. Comput. Algebra 39, 61
[16] Joyner D and Stein W 2014 Sage Tutorial (CreateSpace)
[17] Zimmermann P et al. 2013 Calcul mathématique avec Sage (CreateSpace); freely downloadable from
http://sagebook.gforge.inria.fr/
[18] Bard G V 2015 Sage for Undergraduates (Americ. Math. Soc.) in press; preprint freely downloadable from
http://www.gregorybard.com/
[19] http://www.sagemath.org/doc/reference/categories/sage/categories/primer.html
[20] http://sagemath.org/doc/reference/tensor/
[21] http://sagemath.org/doc/reference/riemannian_geometry/
[22] http://sagemanifolds.obspm.fr/
[23] Lee J M 2013 Introduction to Smooth Manifolds 2nd edition (New York: Springer)
[24] Steenrod N 1951 The Topology of Fibre Bundles (Princeton: Princeton Univ. Press)
[25] http://sagemanifolds.obspm.fr/examples.html
[26] Apéry F 1986 Adv. Math. 61, 185
[27] Mars M 1999 Class. Quantum Grav. 16, 2507
[28] http://gyoto.obspm.fr/