we derive . The choice of signs presents a problem. The easiest way to resolve it is to derive two iterators, one for each sign as we have done before. Almost all functions except for lineal polynomials, present this or other problems for isolation.

An alternative to computing inverses which are multiple-valued is
the following.
We want to compute a value *x*_{i+1} from a previous value *x*_{i}.
When there are multiple choices for *x*_{i+1}we want to select the one with minimal distance to *x*_{i} for
convergence reasons.
I.e. select the *x*_{i+1} which makes
| *x*_{i+1}-*x*_{i}| minimal.
This observation is a crucial one for our algorithm.
So from
*x*_{i+1}^{2} = *h*(*x*_{i}) we will select
,
the sign depending on whether
or
is smaller.
This resolves the first problem, the choice between multiple
values.
For isolating, we use a function
.
E.g. from
*g*(*x*_{i+1})^{2} = *h*(*x*_{i}) we derive
,
where

Inverse_square := proc( rhs, lhs ) r := sqrt( rhs ); if abs(r-lhs) <= abs(r+lhs) then r else -r fi end;In summary, when the result of an isolating step is a multivalued function, we can take two approaches

- (a)
- Enumerate all iterators, either explicitly as in the case for
*x*^{2}=*h*(*x*) or as a function of an arbitrary integer*n*as for . - (b)
- Leave the choice to be determined during the actual computation, by choosing the one closest to the previous value, and hence improving the chances of convergence.

A second problem that we have with inverting functions is a
domain problem, and it can be illustrated with the equation

from which we isolate

Inverse_sqrt := proc( rhs ) a := argument( rhs ); if a <= -Pi/2 or a > Pi/2 then ERROR( `cannot invert sqrt` ) else rhs^2 fi end;