During these two 1-hour talks, we'll give an overview of the computer algebra system Sage.  Since Sage is built on the programming language Python, some of the discussion will naturally involve Python. For more Python-related tutorials, check out the Beginner's Guide to Python.  

These notes will focus on some basic structures in Sage, some functions of mathematical interest, and some tools that might be helpful to know about as you write your own code.

Programming is best learned actively, so you are strongly encouraged to follow along on your own computer and try some of these examples yourself. To make this possible, we begin by explaining how to run Sage on your own computer. There are two natural ways to do this.

• Since Sage is free for everyone, you may install Sage on your own computer and run it locally using the command line. Go to http://www.sagemath.org and follow the links to download and install Sage. (Warning: this is a bit tricky if you run Windows.)
• Besides the command line, Sage also offers a graphical interface, the Sage Notebook, in which you use your web browser to access a Sage server on some possibly different machine. For example, this presentation is being served from a computer at ICERM running a Sage server. But you don't have to set up your own server to run Sage; there is a public notebook server on which anyone can create an account and run Sage! This is by far the easiest way to try out Sage right now. To do this, please go to http://www.sagenb.org and create an account. (For those of you with a wired connection to the ICERM notebook server, you can also create an account there: https://10.9.160.16:8000.)
• Notebook worksheets can be published so that anyone can see them in a static form, even without running Sage. For instance, see http://sagenb.org/home/pub/4181/ for a published copy of this worksheet. Better yet, if you've created a notebook server account, you can click "Login to edit a copy" and then play with a copy of the worksheet yourself!

So, if you have a computer, start by getting a copy of this worksheet to follow along and edit. We'll be running the worksheet using the notebook interface, though of course, you can copy the relevant functions into the command line.

Using the Sage notebook

If you have successfully started a notebook session, you should see something that looks much like this window.

The box below is called a cell, and can be used to evaluate any Sage command. For example, try clicking on the cell, typing 2+2, and clicking "evaluate". (A shortcut for "evaluate" is Shift+Enter.)

You'll see the answer appear in blue below the cell, and then a new cell is generated so that you can type another command. You can also go back and edit the previous cell, but the answer won't change until you evaluate again. You can even insert new cells between existing cells: if you click on the blue bar that shows up when you mouse between two existing cells, a new cell will pop up in between.

If you Shift-click instead, you get a text box like this, which supports some formatting and even basic TeX commands (e.g., x^2 vs. x^2). Once you click "save changes," you can double click back on the text box to resume editing.

For basic code-commenting, use the # symbol.

Besides individual calculator-style expressions, a cell can contain a sequence of instructions. The last expression is evaluated and printed; you can also add "print" commands to force additional printing.

Each cell evaluation remembers any definitions from cells that were evaluated previously, including variables and functions.

Note: you will see a thin red line by the side of the cell if the cell has not yet been evaluated.

Warning: Sage will let you evaluate cells out of order. It is the order of evaluation that counts, not the order of appearance in the worksheet.

If you try to evaluate a cell which contains a mistake, such as trying to use a variable which is not defined, Sage will give you an error message. You can click on the output to see a more verbose error message, which may help you isolate the problem if it occurs in a large cell.

Below we assign a value to a variable, print it, delete it, and observe the ensuing error:

Note that variables do not need to be declared before being used; in particular, there is no need to specify in advance what type of object is going to be assigned to a given variable.

So far our variable names have only been one character long. However, this is not required: you may use any sequence of letters, numbers, and the underscore _ as a variable name as long as it starts with a letter and does not coincide with a Python reserved wood (such as "print"). 

Besides integers, some other basic types of objects include rational numbers, real numbers, and complex numbers (where capital I denotes the chosen square root of -1). These support the usual arithmetic operations.

Another basic object type is strings, which are enclosed in either single or double quotes. One common operation on strings is concatenation.

Arrays

Besides simple types like numbers and strings, one also has compound types like arrays. Arrays can be specified using square brackets (the entries need not be all of one type).

One also uses square brackets to access the individual entries of an array, or even to assign them. Two important things to note:

• Python indexes starting from 0, not 1.
• You may also use negative indices: -n denotes the n-th term from the end.

Some other ways to construct arrays are the following.

• One can concatenate existing arrays using the + operator (see above).
• One can modify in place entries of an existing array (see above).
• One can form slices of an existing array by picking out a range of values. This is the safest way to make a copy of an array (see below).
• Some functions return arrays, such as the "range" function.
• One can use list comprehensions to apply a function to each term of one array to make a new array. There is also the option to put in a conditional statement to pick out only some of the terms of the original array (using == for equality, rather than = which means assignment). 

Warning: arrays are copied by reference, not by value. This is in fact true for all Python/Sage objects, but the fact that arrays can be modified after they are created (that is, they are mutable) creates a real danger.

Conditional evaluation

Like most programming languages, Python supports conditional evaluation via such mechanisms as for loops, while loops, and if-then-else constructions. Here is an example.

Let's step through this example in detail.

• The first line creates the for loop. The range is created using the "range" function described above.
• Everything within the for loop is indented. This is not optional! Python uses this indentation to figure out where the loop starts and ends. The notebook will help you: after you type the "for" line (ending with the colon), the next line will be indented appropriately.
• The "if" command takes a Boolean expression. As we saw before,  == denotes equality, as opposed to a single = which denotes an assignment.
• The "else" command is optional. Again, the indentation tells Python where the if and else clauses begin and end.
• The "print" command can take multiple arguments, and adds a line break unless you end it with a comma.

Functions

By now, you have probably noticed that much Python functionality is provided via callable functions, such as "range". Sage extends this functionality by specifying many new advanced mathematical functions.

Sage includes a couple of useful techniques for inquiring about functions. One of these is tab completion: if you type part of the name of a function and hit Tab, Sage will attempt to complete the name of the function. On one hand, this can save a lot of typing.

Perhaps more usefully, if more than one completion is possible, Sage will show you all possible completions; this can be a useful way to find out about what is available in Sage. (This technique is even more possible when applied to object methods; see below.)

Another important inquiry technique is introspection: if one evaluates the name of a function followed by a ?, Python will show you a bit of documentation about that function. For instance, if you have forgotten how to specify a range other than 0, ..., n-1, we can use introspection on the range function.

Python and Sage also allow for user-defined functions. As with variables, these may be defined in one cell and then used in later cell evaluations. (These will not admit introspection unless you do some extra work, except for source code viewing, but they will admit tab completion.)

Mathematical objects in Sage

One important difference between Python and some lower-level programming languages like C is that Python is object-oriented. That is, besides the variables and functions that one can define globally, one can also create objects with their own variables and functions attached to them. In Sage, this framework is used to implement the construction of mathematical objects in a rigorous fashion which corresponds pretty well to the way mathematicians are used to thinking about these objects. For example, one can create such objects as the ring of integers and the field of rational numbers.

Here are some ways to initialize the field of complex numbers:

We can initialize elements of these fields:

Here are examples of some fields of arithmetic interest:

One can then feed these into more complicated constructions, like the ring of polynomials in a single variable.

In this example, we have created a polynomial ring over the rationals with a distinguished generator, to which we have assigned the name x. We can now generate elements of the ring R simply by writing down expressions in x.

The "parent" command here is an example of a method of the object poly.

Now that we can make polynomials over the rationals, what can we do with them? An excellent way to find out is to use tab completion: if one types "poly." and then hits Tab, one is presented a list of all of the methods associated to poly.

In the previous example, the "factor" method did not require any additional arguments. In other examples, one or more arguments may be required.

This syntax might seem a bit strange: the extended GCD operation is essentially symmetric in its variables, so calling it in an asymmetric fashion may be counterintuitive. There is an extremely good reason for using the object-oriented syntax, namely tab completion. One can for instance type "poly." and his Tab to see the list of all of the methods associated to poly!

As for bare functions, one can also type a few characters and get only the methods that start with the characters you type. For example, if you can't remember whether the method for factoring a polynomial is called "factor", "factorize", "factorise", "factorization", or "factorisation", you can check by doing a tab completion:

There can sometimes be some ambiguity about what the correct parent of a mathematical object should be. For instance, 3/4 is a rational number, but it can also be viewed as a polynomial over the rationals, e.g., when one wants to add or multiply it with another such polynomial. For the most part, Sage will take care of this for you automatically.

Sometimes, however, one needs to make this change of parent explicit, e.g., in case one wants to call a method which exists for polynomials but not for rationals. For example, this fails:

This change of parent (called coercion) is usually accomplished by the following syntax, which looks like plugging the element into the new parent viewed as a function.

Here we create a multivariate polynomial ring over \mathbb{Q}, initialize some functions, and compute a resultant:

We can create rational functions by starting with polynomials:

We can create a power series expansion by coercing each polynomial into the relevant power series ring:

Suppose you need to copy the above power series into a paper. Sage can do that for you too!

Plotting

Sage has many more mathematical features than we can introduce here (but which are well-documented). We'll say just a few things here about plotting; check out the online documentation for more examples.

What else can Sage do?

• Communicate with other mathematical software. Sage itself ships with many well-regarded free software packages, such as Pari (number theory), Gap (group theory), Singular (commutative algebra), R (statistics), etc. Sage can also communicate with nonfree packages such as Mathematica, Maple, Matlab, and Magma if you have them installed. This means that you can access the power of many software packages while (mostly) only having to deal with one well-designed programming language!
• Communicate with TeX at various levels. For instance, any Sage object has a method that returns its representation in TeX. An even more spectacular example is SageTeX, a TeX package that allows your TeX document to pass inputs to Sage and retrieve the answers
• Annotate worksheets by inserting formatted text and even TeX code between the cells, as in this presentation.

 For more on Sage, there are tutorials and documentation available here: http://www.sagemath.org/doc/