/// \defgroup core Core
/// All computer algebra functionality in the form of C++ classes.
///
/// \defgroup cleanup Cleanup
/// Functionality to clean up expressions so that they satisfy the requirements
/// of a consistent expression tree.
/// \ingroup core
///
/// \defgroup display Expression display
/// Classes to handle printing of expressions in various formats.
///
/// There are several different requirements for printing, depending on whether
/// output is to the console, the graphical notebook, or to a different
/// computer algebra system. In the latter case, one typically also needs
/// to be able to convert the output of that external system back into
/// Cadabra-parsable format, which is what e.g. the DisplayMMA::import
/// and DisplaySympy::import member functions do. 
/// \ingroup core
///
///
/// \defgroup compare Expression comparison
/// Functions to compare and match expressions stored in Ex objects. 
///
/// These can involve wildcards and dummy indices, and matching may depend on 
/// the properties attached to symbols.
/// This is an important bit of functionality used widely throughout the Cadabra core.
/// All substitution and component evaluation logic depends on this module.
/// \ingroup core
///
/// \defgroup files Notebooks and packages
/// Graphical notebook interface and Cadabra packages.
///
/// Functionality to store and manipulate Cadabra notebooks and use them as
/// packages inside other notebooks or scripts. 
/// \ingroup core

/// \defgroup pythoncore Python Core
/// Python wrapper around the C++ core module.
///
/// This wrapper makes the entire 
/// functionality of Cadabra accessible from Python. This consists of two
/// parts. One is core/cadabra2_defaults.py, which is a pure-python file.
/// It contains the display function to show Cadabra objects to the user
/// in a UI-independent way (e.g. switching between a text representation
/// on the command line and a LaTeX representation when running in a notebook).
/// The other part are the various files in core/pythoncdb, which build
/// the cadabra2 module for python, to be imported with 'from cadabra2 import *'.
///
/// The Python module has functionality to import Cadabra notebooks using
/// standard Python import syntax. This functionality is part of the
/// \ref files module and described there.
/// \ingroup core

/// \defgroup scalar Scalar algebra
/// Functionality to make Cadabra interface with scalar computer
/// algebra systems such as Sympy or Mathematica.
///
/// It converts scalar
/// parts of Cadabra expressions ('things without indices') to one of
/// these systems, runs them through, and then converts back to Cadabra
/// notation. Currently available are SymPy and Mathematica backends.
/// \ingroup core

/// \defgroup numerical Numerical evaluation
/// Functionality to evaluate mathematical expressions numerically.
/// 
/// Cadabra's symbolic expressions can be evaluated numerically,
/// e.g. when you want to plot a function. Cadabra contains its own
/// fast numerical evaluator and its own numerical tensor types.
/// \ingroup core

/// \defgroup algorithms Algorithms
/// Containing all algorithms acting on symbolic expression trees.
/// \ingroup core
///
/// \defgroup properties Properties
/// Containing all properties that can be attached to symbolic expressions.
/// \ingroup core
///
/// \defgroup clientserver Client-Server 
///
/// Base classes (independent of any GUI toolkit) to write Cadabra
/// clients and servers.
///
/// All clients use two threads. One is the main thread and runs
/// most of the logic in the DocumentThread object. The other one is
/// a thread which communicates with the server process; code for
/// this thread is in the ComputeThread object.  One typically
/// subclasses the former into a full-fledged object driving the
/// graphical user interface.
/// 
/// All functionality that deals with GUI updates is isolated in
/// GUIBase. A client should derive from this abstract base class
/// and implement the methods there. Clients should also derive from
/// DocumentThread, but there are no abstract virtual members
/// to implemented from this base class.
/// 
/// All actual updates to the document stored in the
/// DocumentThread::dtree member are made on the GUI thread as
/// well. The compute thread merely puts requests to change the
/// document onto a stack, and then requests that the GUI updates
/// the document.
///
/// In order to enable undo/redo, all updates to DocumentThread::dtree 
/// are made by putting objects derived from ActionBase onto the 
/// action stack. See DocumentThread::queue_action for details.
/// These ActionBase objects (among which ActionAddCell, ActionRemoveCell, 
/// ActionInsertText, etc) get executed on the GUI thread, and contain
/// the actual logic to perform updates to the document and related
/// GUI elements. 
///
///
/// \defgroup libcadabra2 Cadabra C++ library
///
/// All Cadabra functionality can be used directly from C++ programs without
/// using the Python frontend. A sample program can be found in
/// c++lib/simple.cc:
/// \include c++lib/simple.cc
///
///
/// \defgroup frontend Front-end
/// All code which implements graphical front-end notebook interfaces.