- [Instructor] The focus of this video is going
to be on sequences,
which you have hopefully already seen.
If you don't know what a sequence is,
I encourage you to review those videos on Khan Academy.
But we're going to focus on
how we can generate the same sequence
with different functions that have different domains.
So let's just start with an example sequence.
Let's say we have a sequence.
It's a six.
You could call that the first term.
Some people would call that the zeroth term, six.
And then if that's the first term,
the second term is now a 12,
then a 24,
then a 48,
and so on and so forth.
And as we'll see, there's multiple function definitions
that could create the sequence.
One way to think about it is this is six times one.
This is six times two.
This is six times four.
This is six times eight.
So it looks like each term
is six times a power of two.
Let me make that clear.
This one right over here is six times two to the zero.
That's six times one.
This one over here is six times two to the first.
This one over here is six times two squared,
six times four.
This right over here is six times two
to the third.
And so one way to view this is
if you view this as the zeroth term.
We could define a function,
call it a of n,
where n is referring to our index
or which term in the sequence.
And it's equal to six times two,
six times two to the n,
where n starts at zero,
and then it keeps incrementing by one.
So it's really all integers greater than or equal to zero.
And it's very important to specify that domain,
where n is an
integer and
n is greater than or equal to zero.
You could see what happens if n is not an integer.
If you tried to put a 1.5 year
or something like that, then you're not going
to get one of the terms in the sequence.
And if we don't start at zero, if we started at one,
then this would be the first term in the sequences,
which is not what we want.
We want to generate the sequence
that I originally wrote down.
And obviously, if you started at n equals negative one,
then you're gonna get a different value for your first term.
So this is one way
to essentially define or create a function
which generates this sequence.
But as we'll see, there are other ways to do it.
For example, let me do another one.
I'll do it in another color.
Let's say I have b of n.
And let's say I want to,
instead of saying, okay, I'm gonna start at n equals zero,
and you could kind of view this as the zeroth term,
I want to start at n equals one.
So what you could do is,
is when you input a one, this essentially becomes a zero.
How do I do that?
Well, I just subtract one from it.
So I could say six times two
to the n minus one power,
where n is
an integer
and n is greater than
or equal to one.
Notice, now when we put n equals one in here,
we could maybe call this the first term.
We want to generate a six.
So what happens?
One minus one, we get that zeroth power
that we want right over there.
And so six times two to the zero is indeed six.
Then when n is equal to two,
it's six times two to the two minus one,
which is just two to the first power.
So it just becomes six times two, which is equal to 12.
So notice, these are different function definitions
with different domains,
but they're generating the exact same sequence.
We could also do it recursively.
And we've seen this in other videos.
We can define a function recursively.
We could say, all right, look,
it looks like each of these terms
in our sequence is twice the previous term.
So we could,
if we want a recursive definition for the sequence,
we can define the first term,
or, in this case, we could say the zeroth term
if we want to start at n equals zero.
T of zero is equal to six.
And then we could say t of n
is equal to two times
t of n minus one,
t of n minus one.
And then this is going to be for,
or maybe I'll write it this way, where
n is an integer
and n is greater than
or equal to zero.
This would also generate the sequence.
When you put n equals zero here, you'll get that term.
When you get n equals one,
t of one is going to be two
times t of one minus one, t of zero.
In that case, it'd be t of,
or, sorry, it would be two times t of zero is six.
So two times six, it would get you 12.
Now if you wanted it so that it generates the six
when n equals one, you could do it this way.
You could write it,
actually, maybe I should have kept all of that,
or I'm gonna have to rewrite all of that.
But you could write it this way.
Instead of saying t of zero is equal to six,
we could write t of one is equal to six.
But now we'd have to write a different domain,
where n still has to be an integer.
N is an integer.
And now instead of saying n
is greater than or equal to zero,
now n is greater than or equal to one.
So hopefully this video hits the point home
that there's multiple ways,
either with a traditional,
I guess you would say explicit function
or a recursive function like this.
And even in either of those cases,
you could have different domains
and different function definitions
that generate the same sequence,
but you really have to think about the domain.