Difference between (Names of ) Symbols and Mathematical Objects [closed]

Question

The documentation says: "The Wolfram Language by default interprets any sequence of letters or letter‐like forms as the name of a symbol."

But when I test for example the object "=OverHat[x]" I get the error message: "The string "Overscript[x, ^]" cannot be used for a symbol name. A symbol name must start with a letter followed by letters and numbers."

Letters with (user-defined) diacritics are also not accepted as symbol names. https://reference.wolfram.com/language/tutorial/MathematicalAndOtherNotation.html#41 <- just above this html-anchor

1. I have no idea what a letter-like form really is.
2. Does it make sense to use objects as variables or should I use only symbols?
3. If I understand correctly, objects with annotated names are in fact unary operators. But I suppose that they are used in a different way.

Answer 1

I'm not really sure if an answer is appropriate here, and I'm on the verge of voting to close this question. But for now, here are some thought about your three questions/issues:

1. I have no idea what a letter-like form really is.

The documentation that you linked to has large lists of letter-like forms. I suggest that you just read through that section. Basically, letter-like forms are free from any special parsing rules, and so get treated as symbols (as does any catenation of them).

2. Does it make sense to use objects as variables or should I use only symbols?

This is where things get tricky. This might be a bit much if you're new to Mathematica, but there aren't really variables in the traditional programming sense. What I'm calling the "traditional sense" here is where variables are really just aliases to memory locations. In Mathematica everything is just an expression. Some expressions have rules for how to "compute" or "transform" or "rewrite" them. If I evaluate x = 7 what I am NOT doing is allocating memory for an integer and using x to reference what's stored there. What I AM doing is saving a rule in the "environment" that says that whenever the evaluator encounters x it should replace it with 7. It's abstract and complicated and not really appropriate here, so I'll leave it at that.

So, your question doesn't really make sense. You should use raw symbols or more complicated expressions as needed. There is no rule about that (other than the basic rules of syntax and evaluation that are built in). So, if it makes your situation semantically clear to say x = 7, then do that. If it would be clearer to say x[1] = 7, then do that. But either way, you're just creating rewrite rules.

3. If I understand correctly, objects with annotated names are in fact unary operators. But I suppose that they are used in a different way.

I'm really not sure how to interpret this one. I think maybe what you mean by "objects with annotated names" is headed expressions. An expression like Sqrt[7] has Sqrt as its head. Now, Sqrt has built-in rules associated to it, and you can think of it as a unary operator, but that's just a model to carry around in your head. To Mathematica, Sqrt[7] is just an expression.

So, OverHat[x] is just another expression. Out of the box, it has no built-in rewrite rules associated to it. But you can make your own: OverHat[x] = 7. As it turns out, this probably isn't a very good thing to do, as there's nothing preventing x itself from being assigned its own rewrite rules, e.g. x = 17, in which case the rule OverHat[x] = 7 will be masked so that if you evaluate OverHat[x] now, you'll get OverHat[17].

Answer 2

$Version

"13.2.0 for Mac OS X x86 (64-bit) (November 18, 2022)"

Clear["Global`*"]

Assigning a value to OverHat[x]

OverHat[x] = 3

(* 3 *)

OverHat[x]^2 + 3 OverHat[x] + 1

(* 19 *)

Clear the value

OverHat[x] =.

Solve[OverHat[x]^2 + 3 OverHat[x] + 1 == 19, OverHat[x]]

EDIT: To use both x and OverHat[x]

x = 4;

OverHat[x] = 5;

x*OverHat[x]

(* 20 *)

With a pattern definition

OverHat[x_] := StringForm[
  "OverHat's argument is ``", x]

OverHat[y]

OverHat[x] is not affected

OverHat[x]

(* 5 *)

?? OverHat