Sequences and Notation
Learning goals
- Define a sequence as a function on the positive integers
- Separate the index from the term it names
- Contrast an explicit rule with a recursive one
- Supply enough seeds for a recursion that looks back steps
- Read with both limits included
- Treat the summation index as a dummy name
A sequence is a function on the positive integers
Definition. A sequence is a function whose domain is the set of positive integers . (Some sequences are more natural indexed from . When that happens we say so, and the domain is instead. The idea is unchanged either way, because the inputs are still consecutive integers running upward from a stated place, and unless a lesson says otherwise that place is .) If the function is named , we write its output at the input as rather than , and we call the th term of the sequence.
The only genuinely new thing in that definition is the subscript. Where you used to write you now write , and where you used to write you now write . The parentheses became a subscript and nothing else moved:
The input is called the index. Because the domain is the positive integers, the inputs arrive in a natural order, then then . That natural order is exactly why a sequence can be written as a list when a general function cannot. The list is not a second object sitting beside the function; it is the function’s output table, read from left to right.
Two habits are worth fixing right away. First, the index and the term are different numbers: above, , so the index is while the term is . Second, order is part of the data. The set does not care which element you name first, but the sequence does, because every term is pinned to a particular index.
Since a sequence is a function, it has a graph: plot the point for each index . But only positive integers are legal inputs, so the graph is a scatter of separate dots and never a curve. There is no point above , because is outside the domain, which means names nothing at all.
Terms, indices, and what a list does not tell you
Some sequences stop. A finite sequence is a function on for some positive integer , so it has exactly terms. An infinite sequence is a function on all of the positive integers, so it never runs out. When someone writes they usually mean a finite sequence with four terms, and the trailing dots in signal an infinite one.
As the definition promised, indexing does not have to begin at . Some sequences are more natural starting from (a bank balance before any interest has been added, say), and then the domain is and the first term is . The idea survives intact, because the inputs are still consecutive integers running upward from a stated place. What you may never do is leave that place unstated. That is because is the fourth term when the count begins at , and the third term when it begins at . Every sequence in this lesson starts at unless it says otherwise.
Now a warning that will save you a lot of grief: a few terms never determine a sequence. Shown you would probably answer “the even numbers”, . But the rule
kills the product term at and so produces those same four terms, and then it hands you . Both rules are perfectly good sequences. A pattern you spot in a handful of terms is a guess, sometimes an excellent guess, but the sequence is whatever the rule says it is. That is why the rest of this lesson is about stating a rule precisely. That is also why a puzzle that shows four terms and asks “what comes next” has, strictly speaking, many right answers.
Check your understanding
For the sequence , what is ?
Since is just , substitute into the rule the way you would with any function.
The index is and the term is . Keep the two apart: the index tells you which term, and the term is its value.
Explicit rules and recursive rules
There are two standard ways to pin a sequence down, and they trade against each other.
An explicit rule (also called a closed form) gives directly as an expression in :
Want the th term? Substitute, and you are done: . You never had to look at any other term.
A recursive rule instead gives one or more starting values, called seeds, and then a rule that builds each new term out of earlier ones:
Run it: , then , then . Those are the same terms the explicit rule produced, which is not a coincidence, and we will prove it in a moment.
The seed is not decoration. Delete it and you no longer have a sequence at all. The bare rule is obeyed by , and equally by , and by infinitely many other sequences, one for every choice of . The rule tells you how to take a step; the seed tells you where you are standing when you take the first one. Leaving it out is the most common error in this chapter.
Some recursions look back further than one step and therefore need more than one seed. To compute from the rule you need both and , so both have to be handed to you. The famous choice and produces , the Fibonacci sequence. In general, a recursion that reaches back steps needs seeds, since the rule alone can never produce the first terms.
Worked example 1 List the first four terms of
Substitute in turn, and let the factor do the sign work: it is at odd indices and at even ones.
At and ,
At and , reduce each fraction as you go:
So the sequence opens A factor of is the standard way to make a sequence alternate in sign, and it is worth recognising on sight.
Worked example 2 Find for the recursion , ,
This rule reaches back two steps, so it comes with two seeds, and you cannot jump straight to . Build the terms in order.
The rule at uses the two seeds:
Now and give , and then and give :
The sequence is Notice what the answer cost: three intermediate terms for one value. Reaching this way would mean computing every one of the terms in between, which is exactly the weakness an explicit rule fixes.
The explicit rule and the recursion , define the same sequence#
Two sequences are the same function when they have the same domain and agree at every index. So what we must show is that these two rules produce the same term at every .
Call the explicit sequence , so that for every positive integer , and call the recursive one , so that and for every .
Begin at the bottom of the ladder. The explicit rule gives , and the seed gives , so the two agree at .
Next, check that obeys the very step rule that was built from. For any ,
and rearranging gives , which is exactly the rule follows.
Now climb. Suppose the two sequences agree at some index , so . Each one then adds the same quantity to that same value to produce its next term, so . Agreement at any index therefore forces agreement at the next index. We already have agreement at , so it propagates to , and from there to , and on through every positive integer. No index can be the first place the two disagree, because the value there is computed from the index below it, where by assumption they already agree.
The two rules describe the same function, so they describe the same sequence. What they do not share is the labour. The explicit rule hands you in a single substitution, while the recursion reaches the same number only after additions.
That is the trade in general. A recursive rule is usually the easier one to write down, because it often states plainly what is happening. Such a rule often says: add the next odd number, double the previous term, add the last two. An explicit rule is the one you want when you need a distant term, because it does not care how far out you go. Neither kind is more correct than the other. They are two descriptions of one function, and a good deal of the skill in this chapter is moving between them.
Check your understanding
A sequence is given by and for . What is ?
Work up from the seed one rung at a time. First use to get .
Now feed back into the same rule to get .
A recursive rule offers no shortcut: every term below the one you want has to be built first.
Sigma notation
Sequences get added. To say “add the first fifty terms of ” you could write . But those dots are an instruction to the reader rather than a definition, and they get worse as soon as the pattern of the terms is not obvious. Mathematics has a compact and unambiguous symbol for the job.
Definition. For integers ,
The symbol is a capital Greek sigma, the Greek , standing for sum. Read the notation as an instruction: let start at the lower limit and walk up through the integers one at a time. Keep going until reaches the upper limit . Evaluate the expression to the right of the sigma at each value of , and add every result. The letter is the index of summation, and the expression being evaluated is the summand. Both limits are included, at the bottom and at the top.
Three features of that notation deserve to be said out loud.
The index is a dummy. Its name is a local label. It appears only under the sigma and inside the summand, it vanishes the moment the sum is worked out, and the answer contains no trace of it:
Rename the index to any fresh letter and the value cannot change, because the terms being added are untouched. The one restriction is that the new name must not already be doing another job in the expression. For instance, renaming to inside would be a disaster, since is the upper limit there.
Counting the terms is an off-by-one trap. Running the index from up to produces the indices , and when there are
of them. Subtracting the limits counts the steps between them, and a list always has one more entry than it has steps. So from to there are five steps but six terms, namely . If you want the argument rather than the picture, shift every index down by . That turns the list into , which plainly has entries, and shifting does not change how many there are.
The summand need not mention the index. In
the index still runs and the summand is still evaluated five times. It simply returns every time. The index controls how many terms there are even when it never appears in one.
A sum of terms of a sequence is called a series. Adding finitely many terms always produces an ordinary number, which is all this lesson needs. What an infinite sum could possibly mean is a real question, and a later lesson answers it.
Worked example 3 Evaluate
Read the limits first. The index runs from up to , so the sum has terms, and the summand has to be evaluated at each of .
Working left to right, gives , then gives , then gives , and gives . Adding those four results:
The sum does not begin at , and nothing requires it to. The lower limit is part of the notation, so reading it as a out of habit would have thrown in the extra term . That term is harmless here, but it will not be next time.
Worked example 4 Write in sigma notation
Describe a single term before you describe the sum. Each numerator counts up from , and each denominator is one more than its numerator, so the term whose numerator is is . The numerators run from to , which fixes the limits:
Check the ends before you trust it. At the summand is , and at it is , which are the first and last terms of the original sum.
That answer is correct, but it is not the only correct one. Starting the index at and adjusting the summand to compensate,
produces exactly the same five terms. Both are right. Sigma notation is a way of writing a sum, not a fingerprint of it, so a sum can always be written in many equivalent ways. Prefer the version with the simplest summand, which is almost always the one whose index starts at .
Check your understanding
Evaluate .
The index runs from to , so the sum has terms. Evaluate at each index and add the results.
Starting at out of habit would have added the extra terms and , giving , and forgetting the in the summand would have given .