Vector Fields, Gradients, and Potentials

 1 Set-Up

Once again we will be working with vectors, and so we must load the vect library.  We will also build our usual helper functions mag() and hat() as well as redefine the cross product to  the infix operator ##:

Also note that kill(all) is now off-limits if we do not want to undo everything that we've done above.

 2 Vector Fields as Expressions and Functions

Vector fields are simply functions from either R^2 or R^3 into R^2 or R^3.  That is for a given point (x,y) [or (x,y,z)],
a vector field generates a new point in R^2 or R^3.  We can encode such an object either as an expression:

And then extract values using subst():

--- this works but is inefficient --- or as a function:

In general, we will prefer the latter approach as it is much more streamlined and flexible.

 3 Gradients

The vect library provides a grad() function that produces 3D gradients of scalar functions of either 2 or 3 variables,
but it's a little goofy.  Let's take a look at it:

Ok, so we defined f(x,y,z) and it looks like grad() didn't throw an error, but it really doesn't look like what we were expecting.  We've seen that the vect library often doesn't produce exactly what we want (recall ~ and the express() in the cross product?)  So, let's try to express() the gradient:

This is promising!  So if we express the gradient, we get a symbolic expression that is correct, but not evaluated for the derivatives.  We can get this to evaluate using the ev(,diff) command that we've seen before:

Again the reason behind why this is so obtuse has to do with the different symbolic levels that expressions can occupy in Maxima.  We have functions, expressions, operations, and compound versions of all three of these things.  Since the programmer of the vect library doesn't know what every user expects to get when they compute grad(), they opt for the safest -- highest level -- object that they can: an unexpressed symbolic expression involving the derivative.

We as users have to pull that expression down to the level of a vector field.  This will be the same issue that we will face when we consider the curl() and the div(), and so to help us, we introduce:

 3.1 The "@" Helper Function

We will write our own helper function called @ that will automatically do the ev(express(),diff) part for us, so that we can streamline our work.  So instead of writing ev(express(grad(f(x,y,z))),diff) to get the gradient, we will instead just write:

@grad(f(x,y,z))

You have to admit, that's much better!  The @ symbol will be something called a "prefix" operator since it will prefix whatever
we want to operate on.  Let's define it here:

Now let's see how we use this:

@ works just fine with gradients of functions too:

Note: we could have named @ anything as long as it didn't conflict with operators (like +,-,*,^, etc) that already exist in Maxima.  Further, we will continue to use @ when we apply the curl() and the div() operators later on.

 3.2 Catching the Output of the Gradient

Let's look at f(x,y) from the previous section:

Let's say that we want to take the gradient and then store it in the vector field gf(x,y).  We do it in the usual way:

Now we can compute maximum rates of increase -- for example:

For a gradient involving three variables:

We also note that we can "chain" these operations so that they aren't so cumbersome to type and keep track of all the parentheses.  Let's redo the above example by way of chaining:

 3.3 Notes About grad()

 3.3.1 Only x,y,z Allowed (sort of)

The way that the vect constructs the gradient requires that we use functions (or expressions) with x, y, and z as variables.  We note that grad() works just fine on expressions:

But the operator chokes when the variables are not x,y, or z:

If we look at the symbolic underpinnings of grad():

We can easily see why it fails!  There is a cheap way around this limitation however.  Imagine that we want to compute the gradient of s^2+t^2+u^2.  Then we have:

So we simply swap out the variables for x,y,z, take the gradient, and then reswap back in.

 3.3.2 Always 3D Output

Note that if we have a function of two variables like:

The output is still a 3D vector.  If we insist on a 2D vector as output, we can do the following:

The above chain works by simply dropping the 3rd component from the gradient.

 3.3.3 grad() from Scratch to Fix These Issues

You could always compute a gradient from scratch using partial derivatives like so:

As you can see, the above gets around the limitation of grad() producing only 3D vectors.  Also:

So doing things from scratch removes the requirement of x,y,z variables as well!

 3.4 Finding Critical Points and the Discriminant

Now that we know how to compute gradients, let's try to find some critical points.   Suppose we want to find the critical points of the paraboloid: z=x^2+y^2 --- which we know, of course, to be a minimum at (0,0).

This function only has two variables, so our gradient is only the first two components of grad(z(x,y)):

Recall that solve(): (1) defaults to setting everything to 0 unless told otherwise and (2) always gives a list of solutions, which in this case is a list of points.  We only want the first point, so we ask for solve()[1].

Let's compute the discriminant and test our point.  This is going to require some partial derivatives:

We see that D(0,0)>0 is clearly true, so that the concavity is consistent around the critical point of (0,0).  Let's get that concavity:

Note that the concavity is up at (0,0) and we see that the point we found was a minimum.

 3.5 A More Complicated Extrema Problem

Now consider z(x,y)=x^2 + y^2 - 1/x -1/y

Yikes!  Let's try to_poly_solve() to see if that's any better.  To note, to_poly_solve() requires we list the variables as well as the equations:

To grab the real solutions out of the %union() we use part():

The part(S2,1,1) means first element of S2, first part, while part(S2,1,2) means first element of S2, second part.  It should be noted that:

Were exactly the values that were given in solve(), they were just numerical approximations.  to_poly_solve() was able to extract exact values.  Now let's test the discriminant:

We see that this is positive, so that the critical point has consistent concavity.  Now to determine the behavior:

We see that the second partial is positive and so the graph is concave up at the critical point, making it a minimum.

 4 Vector Potentials

Often it is of importance to us to find a potential function for a given vector field. Thankfully, Maxima's vect library
has a command called potential() that does exactly this, and it works very straightforwardly.  Let's illustrate with
a few examples:

Recall that the potential function is unique only up to a scalar constant, and the above has an additional -1 that could be dropped from the potential.

CAUTION: only use potential with x,y, and z!  Using other variables will reset the variables used in grad() leading to difficult
to diagnose errors in your calculations!

So we see that potential() takes in a vector-field along with a list of variables for that field and then it proceeds to uncover the potential for that field.  Let's put this through its paces a little bit by taking a gradient of a pretty nast function, and trying to
reverse it with potential():

Nice!  Let's ratchet up the difficulty one more notch:

Maxima confides in us that it's having a little difficulty confirming that the above is genuinely correct, but if we trigexpand() the last result:

and then ratsimp() the above:

We see that Maxima has nailed it!