Maybe this is a boring question, but I cannot figure it out. Because every expression has a Head, and Head[1] is Integer, and Head[Integer] is Symbol. Therefore, 1 should somehow represented as Symbol["Integer"][1] or something similar. However, Depth[1] is one which means 1 should be presented as Symbol["Integer..."], not as a expression of depth 2, such as Symbol["Integer"][1].
What is correct representation of 1?
In Mathematica there are compound expressions and atomic expressions.
Anything that AtomQ returns True for is atomic, and may behave in "strange" ways. These must be considered indivisible by users, and only standard and documented ways should be used to extract information from them.
All the rest are compound expressions and have the form head[arg1, arg2, ...]. Here head is the head of the compound expression.
Atomic expressions have "heads" too, by convention. These do not indicate a structure. They are used in practice to indicate the type of the atomic expression so we can programatically distinguish an Integer from a Real. The fact that Head[1] returns Integer does not imply that 1 is somehow represented as Integer[...] because AtomQ[1] is True.
Finally a warning:
Don't be fooled by what e.g. FullForm might show for an atomic expressions (e.g. FullForm[2/3] is Rational[2,3] which looks like it has a structure: an explicit head and two arguments. In reality it doesn't. AtomQ[2/3] is True. In practice atomic objects vary in how they behave when you attempt to disassemble them, but none of them work with all functions that would allow looking into their structure (such as pattern matching on the structure FullForm shows, Part, Extract, Depth, etc.). When you work with some objects, you must read their documentation and only handle them in standard and documented ways. Otherwise your code might misbehave in ways you didn't expect.
Other than the most basic data types in Mathematica (Symbol, String, Integer, Rational, etc.) there are more complex atomic objects such as SparseArray, Graph, Image, MeshRegion, etc. These are made to be atomic so that they can have a more efficient internal implementation.
1[[0]], but cannot get 1[[1]]. All integers are not the same, but if you compare them part by part they are the "same".
$\endgroup$
MatchQ[2/3, _[_,_]]
$\endgroup$
FullForm on atoms sometimes gives things like Rational[2,3]. The pattern-matcher, I believe, is a "lexicographical" matcher (if I'm using this term correctly), so it seems that it matches the structure of the FullForm without regard for the true structure. PS, can't emphasise the it seems enough. It's what it looks like, but don't take my word for it.
$\endgroup$
Replace[1/2, h_[n_, d_] :> {h, d, n}]. Stuff like this also works for SparseArray. For Graph it doesn't work at all (also atomic). Cases[1/2,_] doesn't work but Cases[rational[1,2], _] does. In general, what does and what doesn't work for an atomic object is unpredictable. Also what result you get this way from an atomic object is also unpredictable because they do not really have the structure FullForm shows. However, most atomic objects are really convertible to a compound expression for the purpose of storing ...
$\endgroup$
FullForm[a/b]).
$\endgroup$
IntegerandSymbolare special. While everything must have some head, atomic objects are effectively headless. See iftutorial/BasicObjectshelps to understand. Also, you'll find thatHead[Symbol]isSymbol, but that doesn't mean that everything in the language isSymbol[Symbol[Symbol[...$\endgroup$1is literally1. EvenToBoxes[1]gives"1". $\endgroup$Truewhen tested withAtomQ. On the other hand, you rightly observe thatDepth[1]is 1 although it is atomic. Perhaps, some inconsistency in the documentation. $\endgroup$Integeris anAtom, it is a special type of expression. Therefore,Headof an expression does not imply the expression has a explicit form that start with the head. $\endgroup$