Sage Introductory Programming Tutorial

And it is always helpful to read the documentation to tell if you need an argument (here, one of the columns).

Notice that this gives the SECOND column!  You might have thought that this would give the first column, but Sage (along with the Python programming language) begins numbering at zero.  This is another very important point.

Incidentally, sometimes you will have surprises.  Subtle changes in an object can affect what commands are available, or what their outcomes are.

This is because our original matrix had only integer coefficients, and you can't make the last entry one via elementary operations unless you multiply by a rational number!

Loops, Lists, and Set Builders ("List Comprehension")

We've already seen one or two examples of a fundamental object called a list.  You should think of a list as an ordered set, where the elements of the set can be pretty much anything - including other lists.

Although we won't dwell on it here, it is possible to access any elements of such a list quite easily using square brackets - as long as you remember that the counting starts at zero!

However, our main reason for introducing this is more practical, as we'll now see.

One of the best uses of the computer in the classroom is to quickly show tedious things.  One of the most tedious things to do by hand in linear algebra is taking powers of matrices.  Here we make the first four powers of our matrix by hand.

This is not terrible, but it's not exactly nice either, particularly if you might want to do something with these new matrices.

Instead, we can do what is known as a loop construction.  It is extremely important that we include both the colon in the first line and the indentation in the second line, for that is the basic syntactical structure of Python.

The syntax is vaguely mathematical - for $i$ in the set [0,1,2,3,4], return $A^i$.  Recall that the square brackets create a list, and note that the powers of the original matrix come in the same order as the list.

This is better, but still not perfect.  It would be best to make it quicker to write.  There are two ways to do this in Sage:

These ways of constructing lists are very useful (and demonstrate that, like many Sage/Python things, that counting begins at zero in things like 'range').  The examples below show that one can get step sizes other than one as well.

It is also important to emphasize that the 'range' command does not include its last value!  Confirm this in the examples above.

This all works well.  However, after a short time this will seem tedious as well (you may have to trust us on this).  It turns out that there is a very powerful way to create such lists in a way that very strongly resembles the so-called set builder notation, called a list comprehension. 

We start with a relatively easy example: $$\{n^2\mid n\in\ZZ, 3 \leq n \leq 12\}$$

This is a natural for the list comprehension, and can be very powerful when used in Sage.

This sort of turns the loop around.  The notation is easiest if you think of it mathematically; "The set of $n^2$, for (any) $n$ in the range between 3 and 13."

This is phenomenally useful.  Here is another example, from groups: $G = S_4$, $T=\{|g|\mid g\in G\}$

And plotting! {{{id=55| plot([x^n for n in [2..6]],(x,0,1)) /// }}}

Now we apply it to the example we were doing in the first place.  Notice we now have a nice concise description of all determinants of these matrices, without the syntax of colon and indentation.

Defining Functions (Extending Sage)

It is often the case that Sage can do something, but doesn't have a simple command for it.  For instance, you might want to take a matrix and output the square of that matrix minus the original matrix.

How might one do this for other matrices?  Of course, you could just always do $A^2-A$ again and again.  But this would be tedious and hard to follow, as with so many things that motivate a little programming.  Here is how we solve this problem.

The 'def' command has created a new function called 'square_and_subtract'.  It should even be available using tab-completion!  If you type 'square_and_subtract?', then the documentation string should appear.

Here are things to note about its construction:

• The input is inside the parentheses.
• The indentation is important, as above.
• The documentation string typically is started and ended with three quotation marks, and is optional (though usually is a good idea to include!).  Mathematics can be typeset by putting the math into backticks `A` (preferred) or normal dollar signs \$A\$.
• There will usually be a return value, given by 'return'.  This is what Sage will give below the input cell.

You may have noticed that there is nothing that requires the input 'mymatrix' to be a matrix.  Sage will just try to square whatever you give it and subtract the original thing.

Try to define a function which inputs a matrix and returns the determinant of the cube of the matrix.  (There are a few ways to do this, of course!)

Gotchas

Before we finish the tutorial, there are a few things that often trip people up, mostly related to symbols, which should be pointed out.

One thing is that it's possible to clobber constants!

Can you figure out why $i=4$?  Look carefully above to see when this happened.

By the way, this isn't necessarily bad (for instance, if you are only dealing with real matrices!), but definitely is something a Sage user needs to know.  Also, it's possible to restore symbolic constants.