7.2.4 The More Important Half of the Fundamental
         Theorem: Representation of Functions

Sometimes the procedure

`int_a^bftext[(]t text[)] dt =``int ``ftext[(]t text[)] dt |_a^b`

provided by the Fundamental Theorem is an enormous help in evaluating definite integrals. But for this to be the case, an antiderivative must be relatively accessible. Often we will find that this is not the case. Finding an antiderivative may be extremely difficult or even impossible if what we mean is finding a simple formula into which we can substitute `a` and `b`.

Often our real problem is to find an antiderivative — for example, if we are solving a differential equation. In this section we will see that the Fundamental Theorem can be an enormous help in that direction as well, showing us how to find antiderivatives when we have some other way to evaluate definite integrals.

As you have seen already, there are other ways to evaluate definite integrals. For example, almost every calculator or mathematical computer system has an integral button or menu choice. Thus, with the aid of technology, we can consider the problem of evaluating a definite integral to be solved — without any help from the Fundamental Theorem.

In the next chapter we explore ways to get quick and accurate approximations of integrals — possibly including ways that may be programmed into your calculator or computer. For now we consider only the simple approximation on which we based the definition of the definite integral. We can estimate the value of

by calculating the left-hand sum

for a large value of `n`. Two pages back we observed that the process of forming left-hand sums coincides with the process of solving an initial value problem by Euler's Method, and we used that connection to relate evaluation of a definite integral to antidifferentiation. Now we look at the same process and connection, but with a slightly different interpretation — one that arises naturally if the definite integral problem is solved and the antidifferentiation problem is unsolved.

We think first of accumulating the sum `sum_(k=1)^nftext[(]t_(k-1) text[)] Delta t` one term at a time — just as you would if you were adding up the terms with a calculator. We begin with a starting sum of zero, which we call `s_0`. Then we add the first term `ftext[(]t_0 text[)] Delta t` to `s_0` to get a first sum `s_1`:

Now we add the second term,  `ftext[(]t_1 text[)] Delta t`, to get the second sum:

We continue in this manner, adding a term at a time. At the `k`th step, we have the `k`th sum:

As we have observed already, this equation is Euler's Method for solving an initial value problem: The rise from `s_(k-1)` to `s_k` is obtained by multiplying the slope `ftext[(]t_(k-1) text[)]` by the run `Delta t`. Specifically, the problem whose solution is being approximated is

In the abstract, we know the solution of this initial value problem: `stext[(]t text[)]` is the antiderivative of `ftext[(]t text[)]` whose value is `0` at the left endpoint of the interval over which we are integrating `ftext[(]t text[)]`.

Now, instead of using this connection between integral and antiderivative only at the right endpoint `b`, let's think about the function `s` — a particular antiderivative of `f` — over the entire interval from `a` to `b`. In particular, we want to find a way (other than solving the initial value problem explicitly) to calculate the values of `s`. We let `x` stand for a number in the interval `[a,b]` — a number that is temporarily fixed, but arbitrary. If the number `n` of steps in the summation `sum_(k=1)^nftext[(]t_(k-1) text[)] Delta t` is very large, we can find a `t_k` as close to `x` as we like. Thus after `k` steps the sum will approximate

But the sum also approximates `stext[(]x text[)]`, so these two expressions must be equal:

That's it! To find a value of `s` at a particular number `x`, we integrate `f` — with help from a computer or calculator, if necessary — from `a` to `x`. And this gives us a way to find a particular antiderivative of `f`. If we need some other antiderivative of `f`, it must be of the form `stext[(]x text[)]+C` for some constant `C`.

Example 4

Solve the initial value problem

`(ds)/(dt)= sintext[(]t text[)]`   with `stext[(]0 text[)]=0`,

both by indefinite and definite integration.

Solution   First we use indefinite integration,

`stext[(]t text[)] =` `int` `sintext[(]t text[)] dt=- costext[(]t text[)]+C`,

for some constant `C`. To match the initial condition, we must have

`0=stext[(]0 text[)]=-costext[(]0 text[)]+C`,

so `C=1`. Thus the unique solution is `stext[(]t text[)]=1- costext[(]t text[)]`.

To find the solution by definite integration, we calculate

`stext[(]x text[)]= int_0^xsintext[(]t text[)] dt=- costext[(]t text[)]|_0^x=- costext[(]x text[)]+1`,

which is clearly the same solution.

Checkpoint 3

The Fundamental Theorem of Calculus Part I. If `f` is a continuous function from `a` to `b`, then `f` is the derivative of the function `F` defined by ${\displaystyle F\left(x\right)={\displaystyle {\int }_a^{x}f\left(t\right)dt\mathrm{.}}}$ Part II. If `F` is any function whose derivative throughout the interval `[a,b]` is `f`, then ${\displaystyle {\displaystyle {\int }_a^{b}f\left(t\right)dt=F\left(b\right)-F\left(a\right)\mathrm{.}}}$

Part I (the more important part, which happened to come second in our discussion) says that definite integrals can be used to find antiderivatives. Part II (the less important part, which happened to come first) says that antiderivatives can be used to find definite integrals. Each of these is a very useful thing to know — and a little bit surprising, since the processes leading to the two concepts are so different.

On the other hand, these statements are a little less surprising when we think of the discrete processes that approximate the continuous ones for small values of `Delta t`, namely, taking quotients of differences and taking sums of products. In this discrete setting, Part I says that addition can be used to undo subtraction, and Part II says that subtraction can be used to undo addition. No surprise there!

This leads us to another way to interpret the Fundamental Theorem. We know that addition and subtraction are inverse processes, i.e., that each undoes the other. In much the same way, differentiation and definite integration are inverse processes — almost. It is no surprise that differentiation and indefinite integration (antidifferentiation) are inverse processes — that's in the way we defined the words. And since the Fundamental Theorem says that each kind of integration can be used to calculate the other, it is clear that there should be an inverse relationship between differentiation and definite integration.

But we need to be careful about the "almost." Specifically, suppose we define an antiderivative of `f` by definite integration:

By proclaiming that `stext[(]x text[)]` is an antiderivative of `f`, Part I is saying that differentiation undoes integration with a variable upper limit, or

That is, if you integrate first and then differentiate, you get back where you started.

To interpret Part II in the same way, we think of starting with a function `F` whose derivative is `f`. If, in Part II, we replace `b` with `x` — that is, we think of integrating up to each `x`, one at a time — then Part II says

Thus, if you differentiate first and then integrate — to a variable upper limit — you will not get exactly the same function back unless `Ftext[(]a text[)]=0`. But the function you get back differs from the one you started with by an additive constant, namely, `-Ftext[(]a text[)]`. That's the sense in which differentiation and integration are almost inverse processes.

There is a familiar interpretation of that constant `-Ftext[(]a text[)]`. Think of `F` as distance traveled on a trip in your car. Its derivative is the velocity function measured by the speedometer. In order for your trip meter to record the right distance, you have to reset it to `0` at the start of the trip. Otherwise, if you are going to measure distance by your odometer, you have to subtract the initial reading from the final one. Thus `Ftext[(]a text[)]` is the odometer reading at the start of your trip.

Example 5

Show by direct calculation that

Solution   We saw in Example 4 that

The derivative of this function is clearly `sintext[(]x text[)]`.

Checkpoint 4

Example 6

If `Ftext[(]t text[)]=costext[(]t text[)]`, show by direct calculation that

Solution   The derivative is `F'text[(]t text[)]=-sintext[(]t text[)]` Thus, from Example 4, the integral is `-[1-costext[(]x text[)]]=costext[(]x text[)]-1=Ftext[(]x text[)]-Ftext[(]0 text[)]`.

Checkpoint 5