Introduction to the atlas 2 package  

Description:
 

Modern differential geometry  

Modern differential geometry is the basis for the atlas package.  Such entities as manifolds, mappings, p-forms, tensor fields, bundles, connections are very important in the modern differential geometry. The atlas package allows to work with these entities without extra efforts, just define an entity with corresponding obvious definition and work with it just as you usually do.
The following declarations are trivial and self explanatory: Domain - manifold and domain declaration, Constants - constants declaration, Functions - functions declaration, Tensors - tensors declaration, Forms - forms declaration, Vectors - vectors declaration, Mapping - declaration of a mapping between manifolds or domains, Coframe - coframe declaration, Frame - frame declaration, Metric - metric tensor declaration.  

 

No programming just differential geometry  

When working on your problem you think in terms of manifolds, mappings, embeddings, submersions, p-forms, tensor fields etc. The atlas package allows you  concentrate on the differential geometry problem not on the programming.  You can use predefined declaration operators to declare various differential geometry objects, which are calculated on the fly: Projectors - automatic calculation of projectors of a mapping, Invariants - automatic calculation of invariants of a mapping, Connection - automatic calculation of connection 1-forms, Curvature - automatic calculation of curvature 2-forms, Torsion - automatic calculation of torsion 2-forms, Riemann  - automatic Riemann tensor calculation, Ricci -  automatic Ricci tensor calculation, RicciScalar - automatic Ricci scalar calculation.  

 

No ugly output just standard notation  

The atlas package uses standard differential geometry notations: d - exterior derivative, - Lie derivative, ι - interior product, - exterior product, - tensor product, - Hodge star, - covariant differentiation, δ - Kronecker's delta symbol etc. You always get output as you expected like the following:

atlas package output example with Lie derivative calculation:  

 

 

atlas package output example with exterior derivative calculation:
 

   

atlas package output example with tensor product calculation:  

 

atlas package output example with covariant derivative calculation:  

 

 

atlas package output example with interior product and Kronecker's delta symbol calculation:  

 

 

atlas package output example with calculation in a manifold with symbolic dimention:  

 

Old atlas package notations are still supported for input purposes and for Classic Worksheet Interface of Maple 14.  

 

Single solving path for almost any problem  

With the atlas package you always have one and the same solving path for almost any of your differential geometry problem. You start with definitions of manifolds, vector and tensor fields, p- forms and mappings between the manifolds. When you get your differential geometry entities defined, you use standard operators to get various quantities of your entities: Projectors - automatic calculation of projectors of a mapping, Invariants - automatic calculation of invariants of a mapping, Connection - automatic calculation of connection 1-forms, Curvature - automatic calculation of curvature 2-forms, Torsion - automatic calculation of torsion 2-forms, Riemann  - automatic Riemann tensor calculation, Ricci -  automatic Ricci tensor calculation, RicciScalar - automatic Ricci scalar calculation.  

This is standard procedure which can be automated completely.  

For instance for 2D and 3D differential geometry problems the atlas package offers atlasWizard - the powerful Maplet tool to formulate and solve typical differential geometry problems for lower dimentions. You can fine atlasWizard in maplets subfolder of your atlas distribution folder:
{atlas-path}/maplets/atlasWizard.maplet , where {atlas-path} is a path to your atlas distribution folder.  

In higher dimentions you can also automate the solving path by using our templates worksheets (look at {atlas-path}/examples ).  

 

All calculations are as coordinate free as possible  

In the atlas package all calculations are performed in terms of tensors, vectors and p-forms (not their components!). For instance, conformally flat metric tensor of sphere is presented as , where   are coframe 1-forms and symbol ⊗ -  is tensor product operator (see examples below). To get more information about the main principle of the package structure and to look through some complete examples see atlas[examples] . To look through references list see atlas[references] .  

 

Some calculations with symbolic dimension are available  

The atlas package allows one to make some useful calculations even if  the working dimension is symbolic. For example, if is the dimension, are coframe 1-forms and are frame vectors then decomposition (of interior product of vector and 1-form ) - is one of the available calculation. Another example is Lie bracket decomposition:  

To get more information about this possibility see atlas[dim]  

 

Almost any differential geometry entity can be indexed  

In the atlas package any object (constant, tensor, p-form, manifold etc.) can be indexed. This is very flexible feature. For or more information on atlas indexing facilities, see atlas[indexing] .  

 

Easy customizable simplification of your results  

Because computations with tensors and p-forms usually involve a great number of quantities, it is important to make simplification in each step of the computations. For this reason, the user can customize the simplification routine `atlas/simp` for a particular problem. For more information, see atlas[simp] .  

 

Intallation instructions  

Copy the files atlas.hdb , atlas.mla from the {atlas-path}/lib folder, and place them inside the lib folder of your Maple installation. To find out what your Maple lib folder is, execute in your Maple session:

[ > libname;
 

You get strings separated by commas. First string is your path to your Maple lib folder.  

Before using routines of the atlas package, you must load the package with one of the commands with(atlas) , with(atlas,[]), with(atlas,<function>) or atlas[<function>] . See with for details.  

 

Declaration operators  

 

Use these operators to declare various differential geometry entities.  

 

Domain         Manifold and domain declaration
Constants     Constants declaration
Functions     Functions declaration
Tensors         Tensors declaration
Forms           Forms declaration
Vectors        Vectors declaration
Mapping       Declaration of a mapping between manifolds or domains
Coframe      Coframe declaration
Frame          Frame declaration
Metric          Metric tensor declaration  

 

Calculation operators  

 

Use these operators for automatic calculation of various differential geometry objects.  

 

Projectors      Calculation of projectors of a mapping
Invariants       Calculation of invariants of a mapping
Connection     Calculation of connection 1-forms
Curvature       Calculation of curvature 2-forms
Torsion           Calculation of torsion 2-forms
Riemann          Riemann tensor calculation
Ricci                Ricci tensor calculation
RicciScalar      Ricci scalar calculation  

 

Differential geometry operators  

 

Use these operators for standard differential geometry calculations.  

 

d         Exterior derivative operator
       Lie derivative
ι          Interior product operator
      Exterior product operator
      Tensor product operator
       Hodge operator
       Covariant differentiation
grad   Gradient operator
div      Divergence operator  

&d      Codifferential operator
&L      Hodge-de Rham Laplacian  

&/      Pullback of a [0,k] tensor field under a mapping
&D      Pushforward (differential of a mapping)  

 

Utility operators  

Use these operators to control and manage your differential geometry entities.  

 

ToBasis      "ToBasis" decomposision
Who           Lists of all declarations made and shows "who is who"
kind           Kind of a tensor
&$             Generalized interior product operator
&@            Natural vector operator
dual           Dual operator
delta         Kronecker's delta symbol  

 

Examples:  

>	restart: with(atlas):

 

Conformally flat metric on sphere :  

Declare constant :
Constants(lambda);  

(2.1)

 

Declare functions:
Functions(f=f(x,y),h=h(f));  

(2.2)

 

Declear forms:
Forms(e[i]=1,xi=1,theta=p);  

(2.3)

 

Declare vectors:
Vectors(E[j],X,Y,Z);  

(2.4)

 

Declare coframe 1-forms:
Coframe(e[1]=d(x),e[2]=d(y));  

(2.5)

 

Now coframe 1-forms are .  

Declare frame vectors:
Frame(E[j]);  

(2.6)

 

Now frame vectors are .  

Metric declaration:
Metric(g=4*(d(x)&.d(x)+d(y)&.d(y))/(1+lambda*(x^2+y^2))^2);  

(2.7)

 

Calculate connection 1-forms:
Connection(omega);  

(2.8)

 

Calculate curvature 2-forms:
Curvature(Omega);  

(2.9)

 

Riemann tensor:
Riemann(R);  

(2.10)

 

Ricci tensor:
Ricci(r);  

(2.11)

 

Ricci scalar:
RicciScalar(s);  

(2.12)

 

Show 1-form :
'omega[2,1]'=factor(omega[2,1]);  

(2.13)

 

Verify that there is no Killing vector field among frame vector fields:
'L[E[j]](g)'=L[E[j]](g);  

(2.14)

 

Verify that "rotation" vector field  is a Killing one:
Z:=x*E[2]-y*E[1];
'L[Z]'(g)=eval(L[Z](g));  

 

	(2.15)

 

Calculation of volume form using Hodge operator &** :
'&**(1)'=radsimp(&**(1));  

(2.16)

 

Some more calculations:  

Using interior product operator - :
'iota[E[j]](&**(1))'=iota[E[j]](radsimp(&**(1)));  

(2.17)

 

The same with metric tensor g:
'iota[E[k]](g)'=iota[E[k]](g);  

(2.18)

 

Using exterior derivative operator - :
'd(f)'=d(f);  

(2.19)

 

>	'd(h)'=d(h);

 

(2.20)

 

>	'd(f*xi)'=d(f*xi);

 

(2.21)

 

>	'&**(d(f))'=radsimp(&**(d(f)));

 

(2.22)

 

As are coframe 1-forms and are frame vectors then:
'iota[E[i]](e[k])'=iota[E[i]](e[k]);  

(2.23)

 

"ToBasis" decomposition:
X=ToBasis(X);
xi=ToBasis(xi);  

 

	(2.24)

 

See Also:  

atlas[types] , atlas[simp] , atlas[dim] , atlas[examples] , atlas[references] .