# Definition of a Line Integral

 Remember the general concept of the integral of a function f over some domain A. First, the function f is assumed to be defined at least on A. Then the integral is defined as the limit of a sequence of values generated by the following process:

#### to compute an integral...

 PARTITION the domain of integration A into n little pieces, A1,A2,...,An. CHOOSE A POINT from each piece. P1 in A1,...,Pn in An. COMPUTE the value of the following sum:

> #

```                                     n
-----
\
Sn =   )   f(Pj) dAj
/
-----
j = 1```
 Where dAj denotes the size of the jth piece Aj. The integral is then defined as the limit of the sequence of values Sn when the size of the partitions (usually taken to be the size of the largest piece) goes to zero. If the domain of integration, A, is bounded, reducing the size of the partition makes n (the number of pieces) to go to infinity so that,

> #

```                                               n
/                      -----
|                        \
|  f dA = Limit           )   f(Pj) dAj
|         n -> infinity  /
/                        -----
A                      j = 1```

### The Line Integral:

 The line integral of a scalar function f along a curve C (also refered to as the path of integration) is defined as above. Where the domain is now the curve C and the function is a function that assigns a scalar (number) to each point on the curve. It is customary to denote the elemnent of arc length by ds and not by dC as the above notation suggests implicitly. The function f needs to be defined at least on the curve C but it is often known in a much larger part of the space that contains C. Here is an example.

### Example

 Let us compute, straight from the definition, the value of the line integral of the function f(x,y)=x^2-y along the segment of the y=x line from the origin up to (1,1).

> f := (x,y) -> x^2-y;

```                                             2
f := (x,y) -> x  - y```
 an easy way to encode a partition with n pieces all of the same size is to split the interval [0,1] into n equal pieces. The segment has length sqrt(2) (notice that it is the diagonal of the unit square). Thus, each little piece has length sqrt(2)/n. The Riemann sums Sn are then:

> S := n -> sum( f(j/n,j/n)*sqrt(2)/n,j=1..n);

```                                  n
-----
\    f(j/n, j/n) sqrt(2)
S := n ->   )   -------------------
/             n
-----
j = 1```
 where I have chosen the points Pj=(j/n,j/n) at the right hand side extreme of each little interval. Some values for S(n) for different n are:

> S2:=S(2)=evalf(S(2));S10:=S(10)=evalf(S(10));S100:= S(100)=evalf(S(100));

```                                     1/2
S2 := - 1/8 2    = -.1767766953

33  1/2
S10 := - --- 2    = -.2333452377
200

3333  1/2
S100 := - ----- 2    = -.2356786901
20000```
 The exact limit is:

> Answer := Int('f',s) = limit(S(n),n=infinity);

```                                    /
|                1/2
Answer :=  |  f ds = - 1/6 2
|
/ C```
 Maple computes the answer without showing us the details of the derivation. It is a good exercise to try to derive by hand the above result before looking at the gory details of the intermediate steps.

### Using a Parametrization for the Curve C

 When the path of integration is represented in parametric form the partitions can be easily obtained by subdividing the set of parameter values. Recall that a parametrization of a curve is a representation of the points on the curve with a vector valued function of a scalar parameter t. It is convenient to think of the vector function r(t) representing the position in space of a particle at time t.

> r := t -> x(t)*i + y(t)*j + z(t)*k;

`                       r := t -> x(t) i + y(t) j + z(t) k`
 The curve C is the set of all the points r(t) when t is between a and b. By subdividing the interval of time [a,b] into n equal parts: [a,t1], [t1,t2],...,[t(n-1),b] each of length:

> dt := (b-a)/n;

```                                        b - a
dt := -----
n```
 we create a partition on the curve with points: pj = r(tj) = r(a+j*dt) The Riemann sum is then,

> S := n-> sum(f(r(a+j*dt))*'ds.j/dt'*dt,j=1..n);

```                                n
-----
\                    ds.j
S := n ->   )   f(r(a + j dt)) '----' dt
/                     dt
-----
j = 1```
 where ds.j denotes the arc length of the jth piece on the curve. As n approaches infinity the ratio ds.j/dt will approach the derivative of the arc length function s w.r.t. t at the point (tj) on the curve. But as it is clear, from the kinnematic interpretation, ds/dt is the speed of the particle at each time which is measured by the length of the velocity vector |dr/dt|. It then follows that

> Line_int := Int(f,s) = Limit('S(n)',n=infinity);

```                                 /
|
Line_int :=  |  f ds = Limit         S(n)
|         n -> infinity
/ C```
 and this is equal to:

> Line_int := Int(f('r(t)')*v(t),t=a..b);

```                                      b
/
|
Line_int :=  |  f(r(t)) v(t) dt
|
/
a```
 where v(t)=|dr/dt| is the length of the velocity vector at t. The above formula shows how to compute a line integral of a scalar function along a path in terms of a regular integral over the parameter that defines the curve. In particular for the example above: f(x,y)=x^2-y along the straigt line segment from (0,0) to (1,1) is just given by:

> Answer := Int((t^2-t)*sqrt(2),t=0..1) = int((t^2-t)*sqrt(2),t=0..1);

```                              1
/
|    2       1/2             1/2
Answer :=  |  (t  - t) 2    dt = - 1/6 2
|
/
0```
 where we have used the parametrization x=y=t for t between 0 and 1. the straight line segment. Hence, ds=sqrt(2)dt.

Link to the commands in this file
Carlos Rodriguez <carlos@math.albany.edu>