Why can't I define vector v as having subscripted elements v_1, v_2, v_3...?

Question

I'm a very beginner in Mathematica 8 programming. While trying to play a little with tensor analysis I encountered a problem. How to define for example vector in such manner:

v={$v_1,v_2,v_3$}

For now I get the recursive definition, due to the situation in which the v variable is on the right-hand and left-hand sides.

Answer 1

You could also use something like OverVector, since

OverVector[v] = {Subscript[v,1],Subscript[v,2],Subscript[v,3]}

isn't recursive, and so won't cause problems.

This takes a bit more effort to input

Type Ctrl+& and then Esc vec Esc to enter directly

but if you're interested in the typeset forms it might be worth it.

Answer 2

You can't define an unassigned symbolic variable throught itself. You are trying to do something like that:

x = F[x]

This is not right for symbolic computations, because x evaluates to itself as a pure symbolic value.

Your code in FullFrom is:

Equal[v, List[Subscript[v, 1], Subscript[v, 2], Subscript[v, 3]]]

So, you get the recursion.

Try different symbol for your vector:

W={$v_1,v_2,v_3$}

Answer 3

I hesitated to post this as low-level monkeying can break the system in unexpected, serious, and subtle ways. Nevertheless, since other options have been presented, and I believe that $PreRead is fairly safe as it does not apply to internal operations, I shall.

We can use $PreRead to transform user input of the form

Symbolsubscript

into

HoldForm[Symbol]subscript

thereby preventing evaluation of Symbol:

$PreRead =
  (# /. SubscriptBox[x_String, ss_] :> 
        SubscriptBox[TagBox[x, HoldForm], ss] ) &;

This allows:

v = {Subscript[v, 1], Subscript[v, 2], Subscript[v, 3]};

v

{5, 7, 13}

{Subscript[v, 1], Subscript[v, 2], Subscript[v, 3]} = {5, 7, 13};

v

Subscript[v, 3]

{5, 7, 13}

13

FrontEnd screenshot:

Answer 4

Update

Actually, I decided the OverVector solution by @Brett Champion is not a good idea after all. The reason is that it deceives you into thinking you can safely distinguish between the vector variable $\vec{v}$ and the variable v. This is not the case: set v = 7 after defining OverVector[v] with its three components, and you lose the vector definition because now OverVector[v] will return OverVector[7].

So my conclusion is that I would definitely stick with the following approach which has worked well for me in the past (the rest is a slightly edited version of my original post):

If you're doing tensor analysis and need symbolic manipulations where the vector components are functions such as $v = \{v_1(x,y,z), v_2(x,y,z), v_3(x,y,z)\}$, you could also make use of the following:

v = Through[Array[Subscript["v", #] &, 3][x, y, z]]

The output is $\{v_1[x,y,z],v_2[x,y,z],v_3[x,y,z]\}$. These can be used in symbolic manipulations: You can now do operations on the components of v, such as D[v[[1]], x], or on the vector v as a whole, such as D[v,x]. In tensor analysis, these symbolically defined components are what you need most. But you can also assign specific functions or constants to these components:

If I were to assign, say, Subscript["v", 1][x, y, z] = x^2, this would define SubValues for the Subscript operator. The latter is similar to OverVector in that it has no pre-defined meaning in Mathematica, see "Operators without Built-in Meanings" in the documentation. The recursion problem is avoided by making the component names into strings, whereas the vector name is a symbol.

To see what other subscripted variables are defined, type SubValues[Subscript] to get variables indexed by [x,y,z] as above, or DownValues[Subscript] to find subscripted variables such as Subscript["v",0] that aren't functions of x,y,z.

Comparing the above suggestion to the definition

OverVector[w] = {Subscript[w,1][x,y,z],Subscript[w,2][x,y,z],Subscript[w,3][x,y,z]}

my recipe allows you to retain simple notation for your vectors (assuming that you'll mostly be typing their names, not the names of the components).

Edit

In response to the comment by @murray let me add that if you don't like the output with its verbose component form for your vector v, it is always possible to add rules that format the results in a wide variety of ways. For example, assuming my above template for defining vectors, you could define the following rule:

nice = {Through[Array[Subscript[name_String, #] &, 3][x, y, z]] :> name}

Then compare the output of v and v/.nice. The latter just replaces the list of components by the string name which all components have in common (which is also the name of the vector symbol v). For more on how to work with these objects, you may want to look at this MathGroup post.

Answer 5

The Notations package seems to overcome this:

Needs["Notation`"]
Symbolize[ParsedBoxWrapper[SubscriptBox["v", "_"]]]
v = {Subscript[v, 1], Subscript[v, 2], Subscript[v, 3]}

Edit

The symbolized symbol is a symbol with a subscript. In order to make this apply to all subscripts with this symbol "v" I use a pattern:

Answer 6

Well, if our intent is only to see the notation over vector we could do so:

Clear[v]

OverVector[v] = {Subscript[v, 1], Subscript[v, 2], Subscript[v, 3]}

where output is

{Subscript[v, 1], Subscript[v, 2], Subscript[v, 3]}

so

OverVector[v] gives

{Subscript[v, 1], Subscript[v, 2], Subscript[v, 3]}

but if we use the built-in Defer

Defer[OverVector[v]]

we get

\!\(\*OverscriptBox[\(v\), \(\[RightVector]\)]\)