Picard Iterates

Section 2.1 in Borrelli/Coleman

February 19, 1999

Richard Hitt

Introduction

This section discusses the existence and uniqueness of solutions to first order initial value problems of the form , .

Theorem: If and are both continuous throughout a closed rectangle in the plane, and if is a point in the interior of , then the IVP

has a solution on some -interval containing in its interior (existence). Furthermore, the IVP has no more that one solution on any -interval containing in its interior (uniqueness).

The proof of this theorem is carried out by constructing a sequence of functions that converges to the solution of the IVP. Although the proof requires some more advance mathematics that we consider in this course (Cauchy sequences in a complete metric space), it is instructive to examine how the approximating functions are constructed.

If we integrate both sides of the differential equation from to , we get a corresponding integral equation

where the dummy variable is used to avoid confusion with the limit of integration . This integral formulation can be used to construct a sequence of approximate solutions to the IVP. The idea is that given an initial guess of the approximate solution to the IVP, say , an infinite sequence of functions, , can be constructed according to the rule

These functions are called Picard's iterates and the method itself is called Picard's Method.

Getting started

Every Maple worksheet should begin by re-initializing the Maple "kernel" and loading the additional packages that we are most likely to use.

> restart;

> with( plots ):

> with( DEtools ):

Example 1

In this example we will use the Picard method to construct the first few Picard iterates for the most basic IVP we have:

We begin by making the simplest guess possible that also satisfies the initial condition:

> phi[0] := t -> 1;

Next we form using the above formula

> phi[1] := 1 + int(phi[0](s), s=0..t );

This sets equal to an algebraic expression. In Maple's eyes, to make it into a function we have to do

> phi[1] := unapply(phi[1],t);

Continuing, we can combine both of these steps into one step.

> phi[2] := unapply( 1 + int(phi[1](s), s=0..t), t);

This process continues indefinitely. It can be automated slightly with a loop to capture the first 6, say, iterates.

> for i from 1 to 6 do
phi[i] := unapply( 1 + int( phi[i-1](s), s=0..t), t);
od;

Note that in this example, each is obtained from the previous one by the addition of a single term. Does this look familiar?

Each new term is of the form . This makes the Picard iterates the sequence of partial sums for the Maclaurin series for . Thus, the sequence of Picard iterates converges to which is the solution to the IVP.

Let's look at all this graphically.

> plot({exp(t), seq(phi[i](t), i=0..6)},t=-3..2);

Another Example

Let

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

Form the IVP

We can begin the Picard method in Maple again. This time we will take what we did in the previous section and wrap it up in a procedure for handling the Picard calculations. This Maple code defines a procedure called picard (what else) the takes as its arguments the initial values, the function on the rhs of the DE, and the number of the iterate we want computed.

> Picard :=
proc(t0,y0::algebraic, f::procedure, n::integer)
local result;
if n=0 then
result:=unapply(y0,t)
else
result:=
unapply(y0+simplify(int(f(s,Picard(t0,y0,f,n-1)(s)),s=t0..t)),t)
fi
end;

Let's look at the first few Picard iterates.

> seq(Picard(0,0,f,i), i=0..5);

Note that in this example to get from one iterate to the next, the existing terms are left alone and new terms are added. It does not always happen like this.

Now we can compute several iterates and plot them along with a numerical approximation of the actual solution.

> P1 :=
DEplot(
diff(y(t),t)=2*t-y^2, {y(t)},
t=-1..2, y=-1..3,
[[0,0]],
linecolor=BLUE
):

> P2 :=
plot(
{seq(Picard(0,0,f,i)(t),i=0..5)},
t=-1..2,
y=-1..3,
color=RED,
thickness=1
):

> display(P1,P2);

We can animate the sequence of iterates. In the Maple worksheet, you need to right click on the graph below and go to the Animate menu.

> for i from 0 to 5 do
p.i :=
display(
[
P1,
plot(
Picard(0,0,f,i)(t),
t=-1..2, y=1..3,
color=RED, thickness=3
)
]
);
od:
i := 'i':

> display(
[ seq( p.i, i=0..5 ) ],
insequence=true, view=[-1..2,-1..3],
title=`Direction Field and Picard Iterate for y' = 2t - y^2, y(0)=0` );