Working with abstract vectors

Question

I often need to compute derivatives or integrals involving N-dimensional vectors (where the dimension could be equal to 2 or 3 but is not particularly relevant for the sake of the derivation). The only way I know to translate this into valid Mathematica input is to specialize to a particular N and define all quantities component-wise.

A simple example: computing the time derivative of a normalized quantity

V[t_] := {x[t], y[t], z[t]}
Simplify[D[V[t]/Sqrt[Dot[V[t], V[t]]], t]]

While correct, this can obviously get extremely messy fast. At that point, I find it easier to just do the computation by hand using generic vector calculus identities which work for vectors of any dimension.

I was wondering if there is a way of doing such computations using an abstract vector type? This post references a Vectors command that is potentially related, but it was not clear to me how to use it for calculus.

Edit: After some more experimentation with Vectors, I was able to get quite close to what I was looking for:

$Assumptions = V[t] \[Element] Vectors[3, Reals];
Simplify[D[V[t]/Sqrt[Dot[V[t], V[t]]], t]]

$$\frac{2 V(t).V(t) V'(t)-V(t) \left(V(t).V'(t)+V'(t).V(t)\right)}{2 (V(t).V(t))^{3/2}}$$

However, neither Simplify[] nor TensorReduce[] could simplify the commutative dot product in the expression above.

Answer 1

You need to tell Mathematica that both $V[t]$ and $V'[t]$ are vectors:

$Assumptions = (V[t]|V'[t]) ∈ Vectors[{n}];

TensorReduce @ D[V[t]/Sqrt[V[t] . V[t]], t] //TeXForm

$\frac{V'(t)}{\sqrt{V(t).V(t)}}-\frac{V(t) V(t).V'(t)}{(V(t).V(t))^{3/2}}$

Answer 2

Unprotect[Dot];
SetAttributes[Dot, Orderless]
Protect[Dot]

then try to evaluate this again

D[V[t]/Sqrt[Dot[V[t], V[t]]], t]

of course it would be better to define new function based on dot and set it attribute Orderless

Answer 3

It seems the simplest way to simplify such expression is to impose sorting based on CountLeaf

D[V[t]/Sqrt[Dot[V[t], V[t]]], t] /.   
     Dot[a_, b_] :>  Dot[b, a] /; LeafCount[a] < LeafCount[b]

so that for instance the longest expression is always last. This is not bulletproof but it seems to do the trick on your example(?)

In order to deal with equal length cases you could do

(Dot[x, y] - Dot[y, x]) /. 
 Dot[a_, b_] :> Dot[b, a] /; LeafCount[a] < LeafCount[b] /. 
 Dot[a_, b_] :> Dot @@ Sort[{b, a}] /; LeafCount[a] == LeafCount[b]