3
$\begingroup$

This question already has an answer here:

I'm trying to grasp how to Wolfram Language uses symbolic expressions for everything. The concept of doing so makes sense to me, but the language doesn't behave how I predict.

I understand how writing x + y is really writing Plus[x, y].

But my understanding then predicts that writing 56 is really writing Integer[56]. And that writing something like 2 + 3 is really writing Plus[Integer[2], Integer[3]].

FullForm says otherwise, though. If I do FullForm[56] I just get back 56. And if I do FullForm[Integer[56]] I get back Integer[56].

TreeForm agrees with FullForm. Here is what predict I should see when doing TreeForm[Integer[56] + 56 * 2]:

The predicted results of running TreeForm on the previously described input.

And here's what I actually get:

The true results of running TreeForm on the previously described input.

So what's happening to cause these difference between my prediction and what I actually see?

Edit:

The answer may have something to do with "atomic objects", which are briefly discussed here: https://reference.wolfram.com/language/tutorial/BasicObjects.html#15871

It's not very helpful, though. Why are these objects atomic? What is the use of having both 56 and Integer[56]? And why does Head[56] produce Integer if 56 is specifically supposed to be atomic--not breakable into any smaller pieces, like a head? AtomQ is a thing. But what does the Q stand for? http://reference.wolfram.com/language/ref/AtomQ.html is silent on the rationale behind the name.

Edit 2:

Based on answers and comments made prior to this edit, I've updated my understanding.

I think my basic problem was that I assumed that an expression passed to FullForm or TreeForm is not evaluated. This would be the intuitive behavior, especially for a student learning about the order of arithmetic operations.

But that behavior would also require that different functions differ on whether they choose to evaluate an expression or not, and that would introduce an rather arbitrary complexity to the whole enchilada. Users would need to remember which functions do or don't evaluate expressions passed as arguments. Yech.

If, however, I go with the idea that expressions are always evaluated, then it makes perfect sense that FullForm[2 + 2] and FullForm[Plus[2, 2]] give back 4, because 2 + 2 and Plus[2, 2] would be evaluated before FullForm ever got to see them.

And so immediately wondered about how to prevent an expression from being evaluated. And HoldForm appeared, and now I can do TreeForm[HoldForm[2 + 2]] to get:

The results of running TreeForm in the previously described input.

Which is fundamentally what I expect.

However. It still doesn't make sense that Head[56] gives back Integer. As before, 56 is supposed to be atomic. It's obvious that it's useful to be able test what 56 is, but I'm having hard time coping with the idea that a thing described as atomic.. isn't. And that's a different question.

Thanks to those who helped sort me out.

$\endgroup$

marked as duplicate by m_goldberg, garej, Henrik Schumacher, Öskå, rhermans Jul 23 at 7:48

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.

  • 3
    $\begingroup$ You might want to cogitate on the result of AtomQ[56] versus AtomQ[Integer[56]]. $\endgroup$ – John Doty Jul 15 at 20:47
  • $\begingroup$ Others that you might find interesting to ponder: Head[56] and 56[[0]]. $\endgroup$ – bill s Jul 15 at 20:50
  • $\begingroup$ "Q" at the end of a function signifies it returns True or False e.g. PrimeQ, PalindromeQ. $\endgroup$ – lirtosiast Jul 15 at 21:36
  • 1
    $\begingroup$ Related: [How to represent 1 as Symbol[“Integer”]](mathematica.stackexchange.com/q/109639/9490), and Why can't a string be formed by head String?. The accepted answer to the latter is helpful for understanding these types of expressions. $\endgroup$ – Jason B. Jul 15 at 21:41
  • $\begingroup$ Plus is a function that is defined somewere in the system. Integer is not defined, how can it evaluate to anything if it is not defined! $\endgroup$ – Fortsaint Jul 15 at 23:30
3
$\begingroup$

Integer[56] has no special meaning in Mathematica. However, Integer is a symbol, so it's a perfectly valid expression by itself. 56 is a valid argument. So, Integer[56] is a proper expression, although it has no built-in meaning. You may, however, write patterns that match it, so you may define your own transformations that apply to it. That's how Mathematica works: it's an expression rewriting language. If it doesn't recognize a valid expression, it leaves it alone.

$\endgroup$
  • $\begingroup$ This is the solution which unstuck me, thank you very much. $\endgroup$ – MadEmperorYuri Jul 15 at 22:53
1
$\begingroup$

Integer is not a function.

Consider this

a = f[b]
Head@a

f

Now, if the Head of a is f, does it mean that a is the same as f[a]? clearly not. So, why you expect 56 to be the same as Integer[56] given that Integer is not a function?

$\endgroup$
  • 1
    $\begingroup$ The fact that Head /@ {56, Integer[56]} returns {Integer, Integer} is probably the source of some confusion. $\endgroup$ – Jason B. Jul 15 at 21:28
  • $\begingroup$ Just two expressions sharing the same Head, likewise Head /@ {a, f[a]} returns {f,f} $\endgroup$ – Fortsaint Jul 15 at 21:36
  • $\begingroup$ Named "functions" in Mathematica are tricky things. Sin[x] doesn't evaluate like a function, but gets treated as a transformable symbolic expression by machinery whose rules incorporate the properties of the sine function. There is no built-in rule that does anything with Integer[56]. $\endgroup$ – John Doty Jul 15 at 22:53
  • $\begingroup$ My reasoning had gone like this: 1) Everything is a symbolic expression. 2) All symbolic expressions are composed of a head and any number of arguments. 3) Head[56] produces Integer. 4) The information that the integer is 56 must be kept somewhere. 5) That information can't be the head, since that's Integer. 6) So it must be an argument. 7) Therefore, FullForm[56] should produce Integer[56], the same way FullForm[{a, b}] produces List[a, b]. I'm now unstuck as far as this question is concerned, but I'll be making another one that focuses on atomic objects not behaving atomically. $\endgroup$ – MadEmperorYuri Jul 15 at 22:58
  • 2
    $\begingroup$ @MadEmperorYuri You might also wonder why FullForm[a] is a , not Symbol[a] $\endgroup$ – Fortsaint Jul 15 at 23:16

Not the answer you're looking for? Browse other questions tagged or ask your own question.