Posts Tagged ‘Geometry’

Hello again! If you are looking for a Differential Geometry tool, a Sage package which is under development is SageManifold. Let’s see how to install it.

  1. Download the package using the link (currently v.0.2). I’d assume it is saved on your Downloads folder.
  2. Assuming you have SAGE installed, and you have created an alias to call it (see my previous post), run the following command
    $ sage -f ~/Downloads/manifolds-0.2.spkg
  3. To generate the documentation (in case you don’t want to or cannot download it), use either of the commands
    $ sage -docbuild sagemanifolds pdf
    $ sage -docbuild sagemanifolds html
  4. In order for using the package, start your WorkSheet with the command line
    from manifolds.all import *
Have a nice calculation!

Read Full Post »

In a previous post we discuss the definition of the coordinated patch on a manifold, how to define differential forms, wedge them or calculate their exterior derivative… even simplify’em.

This time a zero form will be defined and a list of forms will be created… So, let’s begin!

Define a 0-form

Once created the coordinated patch and the differential forms algebra

sage: reset()
sage: var('t,x,y,z')
sage: U = CoordinatePatch((t,x,y,z))
sage: Omega = DifferentialForms(U)

A 0-form is defined as an element of \Omega^0(U), but the value of the 0-form is given inside the declaration command,

sage: A = DifferentialForm(Omega, 0, exp(x*y))

I tried addition, multiplication, wedge product and exterior differentiation on 0-forms and they worked!

Of course you can combine them with forms of different degrees.

New method of defining a form

I wrote to Joris this morning… but before he was able to answer, from the documentation of the differential form package.

When one calls the generators of the differential form,

sage: Omega.gen(1)

and the result is a differential form… Thus, one can assign a form as follow,

sage: A = sin(x)* Omega.gen(2)
sage: B = cos(y) * Omega.gen(0)
sage: C = sin(z) *Omega.gen(1)
sage: D = cos(y) * Omega.gen(2)

And this forms can be wedged, differentiated, et cetera. ๐Ÿ™‚

List of forms

Finally, after discovering the above behavior I tried the following, a list of differential forms ;-), for example,

sage: pro = matrix([[A, B], [C, D]])
sage: for i in range(2):
...       for j in range(2):
...           show(pro[i,j].diff())

cos(x)dx\wedge dz
sin(y)dx\wedge dy
-cos(z)dy\wedge dz
-sin(y)dy\wedge dz

This implies that somehow one can manage a series of forms by using list properties… I expect to go deeper on this subject in the future! ๐Ÿ˜€

Enjoy people!!!


Read Full Post »

From time to time when one works with operators, such as in Quantum mechanics, something like an exponential of the operator appears (this is also the case in many areas of Mathematics like group theory of differential geometry). This exponentiation of a matrix should be understood as the series expansion of the exponential.

SAGE knows how to do this exponentiation,

sage: reset()
sage: var('a,b,c', domain=RR)
sage: A = a*I*matrix([[0,1],[1,0]])
sage: B = b*I*matrix([[0,-I],[I,0]])
sage: C = c*I*matrix([[1,0],[0,-1]])
sage: A.exp()
[1/2*(e^(2*I*a) + 1)*e^(-I*a) 1/2*(e^(2*I*a) - 1)*e^(-I*a)]
[1/2*(e^(2*I*a) - 1)*e^(-I*a) 1/2*(e^(2*I*a) + 1)*e^(-I*a)]
sage: B.exp()
[   1/2*(e^(2*I*b) + 1)*e^(-I*b) -1/2*(I*e^(2*I*b) - I)*e^(-I*b)]
[ 1/2*(I*e^(2*I*b) - I)*e^(-I*b)    1/2*(e^(2*I*b) + 1)*e^(-I*b)]
sage: C.exp()
[ e^(I*c)        0]
[       0 e^(-I*c)] 

The only problem here is that, even when the relations are simple in this example, I’ve not found a `trivial’ way of simplifying the matrix elements of the exponentiation, not even with the procedure post in here. I didn’t try with the rewrite package

Comments are welcome!



Read Full Post »

A few weeks ago I realize there is a package for working with differential forms in SAGE. So, I’ve tried to take advantage of that!

This is what I’ve learnt so far.

Define your manifold

If you work with differential forms you should know (probably better than me), that you define forms in a coordinate patch… rarely globally.

I’d like to start with something like this!

sage: reset()
sage: # The variables
sage: var('theta,phi,r')
sage: var("bps", latex_name=r"\bar{\psi}")
sage: var("bph", latex_name=r"\bar{\phi}")
sage: var("bth", latex_name=r"\bar{\theta}")
sage: # The coordinate system
sage: coords = [r,theta, phi, bps, bth, bph]
sage: U = CoordinatePatch((r,theta, phi, bps, bth, bph))
sage: Omega = DifferentialForms(U)

From a previous post a weird declaration of variables has been made.

But don’t lose yourself into the code!!!… the important here is:

  • Seven variables have been declared,
  • These are converted into a list,
  • and also are the coordinated of the Coordinate Patch.
  • Finally, \Omega is the algebra of differential forms. Just like \Omega^\bullet(M), where M is the manifold (in this case the patch).
  • Define the differential forms

    Differential form have to be defined… like this,

    sage: A = DifferentialForm(Omega, 1)
    sage: A[1] = -1/4
    sage: A[2] = 1/4*(-cos(theta) - sin(theta))
    sage: A[3] = cos(bps)*sin(bth)*sin(bph)
    sage: A[4] = sin(bps)*cos(bth)*sin(bph)
    sage: A[5] = sin(bps)*sin(bth)*cos(bph)

    The first line defines A as an element of \Omega^1(M).

    The rest of the lines are for setting the components of A. Remember that the coordinates run from 0 to 6 in this example! ๐Ÿ˜› And, of course, they are ordered strictly as we declared them, i.e.,

    A = -\frac{1}{4}d\theta -\frac{1}{4}(\cos(\theta) + \sin(\theta))d\phi + \cos(\bar{\psi})\sin(\bar{\theta})\sin(\bar{\phi})d\bar{\psi} +\cdots

    Exterior Differentiation

    Once the form has been declared, one might differentiate it by using the diff command,

    sage: A.diff()


    (\frac{1}{4} \, \sin\left(\theta\right) - \frac{1}{4} \, \cos\left(\theta\right)) d \theta \wedge d \phi

    Showing the forms

    It’s very useful to see the formulas in a nice written way… this is one of the features I love the more from SAGE, to see your form, use

     sage: show(A)

    Wedge Product

    Of course one of the most important operations when working with forms is the wedge product. For using this, try

    sage: C = A.wedge(A.diff())
    sage: show(C)

    it vanishes. One might try to define another form,

    sage: B = DifferentialForm(Omega,2)
    sage: B[0,1] = sin(bth)

    Note that B\in \Omega^2(M), and has only one non-vanishing component.

    Thus, A\wedge B is calculated,

    sage: A.wedge(B)

    One can also define multiple wedge product,

    sage: A.wedge(B.diff()).wedge(B)

    Needless to say one can multiply a form by a function, or number.

    Simplifying a form

    Forms have not implemented the simplify_full attribute, but their components, which are functions, do. So, after a very complicated calculation one might try to implement a long routine of simplification, say,

    sage: D = A.wedge(B.diff()).wedge(B)
    for i in xrange(Omega.ngens()):
        for j in xrange(i+1, Omega.ngens()):
            for k in xrange(j+1, Omega.ngens()):
                for l in xrange(k+1, Omega.ngens()):
                    for m in xrange(l+1, Omega.ngens()):
                        D[i,j,k,l,m] = D[i,j,k,l,m].simplify_full()

    In the above, Omega.ngens() returns the dimension of the patch. Additionally, each index runs from the value of the previous plus one, in order to avoid repetition (due to anti-symmetric property) or the zeros values.

    if someone find a better way, doesn’t hesitate in post a comment!!! ๐Ÿ™‚

    Well, I think this is much of it! I’ll keep you posted, in case I learn more about ot.

    Enjoy life! and Happy Valentine’s day! ๐Ÿ˜‰


    Read Full Post »