News

Release of 2.2.0 (the "Easter Bunny" series)
(changes).
Loads of new features, available on Linux, OS X and now also Windows.

What is Cadabra?

Cadabra is a symbolic computer algebra system (CAS) designed
specifically for the solution of problems encountered in field
theory. It has extensive functionality for tensor computer
algebra, tensor
polynomial simplification including multi-term symmetries,
fermions and anti-commuting
variables, Clifford
algebras and Fierz
transformations, component computations,
implicit coordinate dependence, multiple index
types and many more. The input format is a subset of TeX. Both a
command-line and a graphical interface are available.

Designed for field-theory problems, with handling of
anti-commuting and non-commuting objects without special notations
for their products, gamma matrix algebra, Fierz identities, Dirac
conjugation, vielbeine, flat and curved, covariant and
contravariant indices, implicit dependence of tensors on
coordinates, partial and covariant derivatives...

Powerful tensor simplification algorithms, not just for
mono-term symmetries but also for multi-terms symmetries like
the Bianchi identity, or dimensionally-dependent symmetries like
the Schouten identity.

Allows for both abstract and component computations.

A standalone graphical notebook interface which can also be
used as a front-end for SymPy.

Input and output using a subset of LaTeX notation.

Programmable using Python.

Cadabra's design philosophy

Cadabra is built around the fact that many computations do not have
one single and unique path between the starting point and the end
result. When we do computations on paper, we often taken bits of an
expression apart, do some manipulations on them, stick them back
into the main expression, and so on. Often, the manipulations that
we do are far from uniquely determined by the problem, and often
there is no way even in principle for a computer to figure out what
is 'the best' thing to do.

What we need the computer to do, in such a case, is to be good at
performing simple but tedious steps, without enforcing on the user
how to do a particular computation. In other words, we want the
computer algebra system to be a scratchpad, leaving us in control of
which steps to take, not forcing us to return to a 'canonical'
expression at every stage.

Most existing computer algebra systems allow for this kind of work
flow only by requiring to stick clumsy 'inert' or 'hold' arguments
onto expressions, by default always 'simplifying' every input to
some form they think is best. Cadabra starts from the other end of
the spectrum, and as a general rule keeps your expression untouched,
unless you explicitly ask for something to be done to it.

Another key issue in the design of symbolic computer algebra systems has
always been whether or not there should be a distinction between the
'data language' (the language used to write down mathematical
expressions), the 'manipulation language' (the language used to write
down what you want to do with those expressions) and the
'implementation language' (the language used to implement algorithms
which act on mathematical expressions). Many computer algebra systems
take the approach in which these languages are the same (Axiom,
Reduce, Sympy) or mostly the same apart from a small core which uses a
different implementation language (Mathematica, Maple). The Cadabra
project is rooted in the idea that for many applications, it is better
to keep a clean distinction between these three languages. Cadabra
writes mathematics using LaTeX, is programmable in Python, and is
under the hood largely written in C++.

History

Cadabra was originally written around 2001 to
solve a
numberof
problems related to higher-derivative supergravity. It was then
expanded and polished, and first saw its public
release in 2007.
During the years that followed, it became clear that several design
decisions were not ideal, such as the use of a custom programming
language and the lack of functionality for component computations. Over
the course of 2015-2016 a large rewrite took place, which resulted
in Cadabra 2.x. This new version is programmable in Python and does
both abstract and component computations. This new web site, with
new tutorials and all manual pages accessible online, will also
hopefully help to make Cadabra easier to use.

Since 2018 Cadabra is available on all major platforms (Linux,
MacOS, Windows, BSD). Visit the Q&A forum for
help using it.