Vector operator and scalar operator

Question

I'm confused about what it means by a scalar operator and a vector operator. We call $\nabla$ , $\nabla\cdot$ ,$\nabla\times$ are all called vector operators. But, the Laplacian $\nabla^2$ is a scalar operator. But, why is $\nabla\cdot$ a vector operator although it generates a scalar field by operating on a vector field? And why is $\nabla^2$ is a scalar operator although it generates scalar and vector field when it operates on scalar and vector field, respectively.

What does decide which one is a scalar operator and which one is a vector operator?

Answer 1

The first thing I learned while using the del operator is that del operator should always be written like: $$\overrightarrow \triangledown=\frac{\partial}{\partial x}\widehat{i}+\frac{\partial}{\partial y}\widehat{j}+\frac{\partial}{\partial z}\widehat{k}$$ Del operator is a vector differential operator.Now let us say there is a function $f(x,y,z)$, and we have to operate the del on it the function can be a vector valued function or a scalar valued function.

1. Del operator on a scalar valued function is like : $$\overrightarrow \triangledown(f(x,y,z))=\frac{\partial f}{\partial x}\widehat{i}+\frac{\partial f}{\partial y}\widehat{j}+\frac{\partial f}{\partial z}\widehat{k}=grad(f(x,y,z))$$ Notice this is analogous to a vector simply multiplied to a constant scalar.

2. Del operator on a vector valued function resulting in a scalar is :

$$\overrightarrow \triangledown .\overrightarrow {f(x,y,z)}=(\frac{\partial}{\partial x}\widehat{i}+\frac{\partial}{\partial y}\widehat{j}+\frac{\partial}{\partial z}\widehat{k}).(f_x \widehat i + f_y \widehat j + f_z \widehat k)$$ $$\overrightarrow \triangledown .\overrightarrow {f(x,y,z)}=\frac{\partial f_x}{\partial x}+\frac{\partial f_y}{\partial y}+\frac{\partial f_z}{\partial z}=div(\overrightarrow f(x,y,z))$$

Notice this is analogous to the dot product of two vectors.

3. Del operator on a vector valued function resulting in a vector is like: $$\overrightarrow \triangledown X\overrightarrow {f(x,y,z)}=\begin{vmatrix} \widehat i & \widehat j&\widehat k \\ \frac{\partial}{\partial x} & \frac{\partial}{\partial y}&\frac{\partial}{\partial z}\\f_x&f_y&f_z \end{vmatrix}=curl(\overrightarrow f(x,y,z))$$ This is analogous to the cross product of two vectors.

Now Laplacian operator is second order differential operator: $$\triangledown^2f(x,y,z)=div(grad(f(x,y,z))=\triangledown . (\triangledown \overrightarrow {f(x,y,z)})$$

$$\triangledown ^2f(x,y,z)=\frac{\partial^2}{\partial x^2}+\frac{\partial^2}{\partial y^2}+\frac{\partial^2}{\partial z^2}$$ It becomes a scalar operator because the gradient gives a vector and divergence is just the dot product on gradient giving a scalar.

Hope this helps...

Answer 2

You are over complicating things quite a bit and suggests a mis-understanding of a deeper(more fundamental and also simpler) concept of functions. You are probably well aware now after 4 or so years but here is the answer:

Every function, of which you listed several which are built from using composition of more basic functions, has an input type or domain and an output type or domain.

What is being said is no different than saying f(x) = x^2 is a "real valued" function. If you are in a vector space over R then you might say it is scalar valued. A vector product returns a vector. The terms signify the co-domain or range kind or type.

So a scalar valued function or a "scalar" operator is a binary operator that returns a scalar. An X valued function is a function that returns values in X or of type X.

It's that simple. They are just letting you know what the type is of the output values of those functions they built.

E.g., grad(f) is vector valued because it returns a vector. In fact it is a grad:function->vector where function is usually a 3 dimensional function over a vector space. dot(f,g) is a binary operator that goes from function x function -> scalars(V).

You can make the notation more precise and mathematicians will do that but the idea is more along the lines of "book keeping". By paying attention to type/kind we can make sure not to put the male parts in to the male parts and female parts in to the female parts. That is, there is an order to the things. Everyone knows this of course but mathematicians make it explicit and some physicists understand it too.

: Process: Look at the type you get out from the operator. For the Laplacian you get a scalar value out... not a vector, so it is a scalar operator. You have to know the input types(usually easy) and the output types(easy if you track them in your language) so you can wire things up in the correct order. Function composition only works when the codomain of the first function is the same as the domain of the second function. E.g., f:A->B, g:B->C, h:Q->C. gf = g o f = g(f) works because we have transitivity: (A->B)->(B->C) = A->C. But you cannot compose f or g with h in any way, they do not go together.

In standard common spoken languages the kinds and types are usually given by context or pronouns(Proper nouns are things that are not composed of other Proper types, they are terminals in language).

In programming you have to know explicitly your functions will work together. Even if they have the right type formulation it does not mean they will give you the answers you want, but it means at least that things won't crash(at least if the functions are pure). Some languages will deduce the types from context too but give you a compilation error when those types don't match(and it can always figure out what thing has what type or should have since type theory is well established now.

So the idea is to just use more explicit language. Once you realize that(and likely you have by now) what they are saying will make perfect sense, well, at least you will feel fluent in the language. Very likely you do it unconsciously by verifying, in your mind when you are "trying to understand" what the effect is of composing functions together. You make sure everything fits correctly(just as a carpenter does or a musician or anyone(everyone does it)) but you actually just gloss over it after a few seconds and only have issues if you think it doesn't line up(as getting types wrong, which is fairly common in everyday language, causes thinks like miscommunication, fights, errors, etc)).

By trying to keep the type well understood by making sure to explicitly define and use it helps reduce the work tremendously and also reduce most errors. You just do quick "type checking" which is just checking transitivity and it's simpler than adding to 1 digit numbers.