When people speak of "symbolic computation" in the context of mathematica, it's usually not about the Mathematica programming language itself, but rather about using Mathematica to do symbolical mathematics. A bit like how you did math with pen and paper in high school or university, except having Mathematica do all the hard stuff.
A lot of Lisp constructs like map and apply and macros have dedicated syntax in Mathematica, so they feel more like a fluent language. And the standard library is very large and impressively self-consistent. The default format is notebooks which helps make your work presentable.
My understanding (from people who properly learnt Mathematica, and understood the language) is it is a lisp, but it's never taught that way, never explained, you're just searching for the magical function that does the thing you want.
Mathematica is basically the M-Expression version of lisp that never developed. The real power isn't just in the symbolic capabilities but the mathematical library.
Lisp is at its core an evaluator for expressions. The routine for that is called EVAL.
Mathematica is a computer algebra system at its core and is a rule-based rewrite system for expressions.
An example in Lisp notation:
In a computer algebra system (CAS) one may enter 5a - 2a
> (- (* 5 a) (* 2 a))
The CAS would answer with:
(* 3 a)
It has used rules to simplify the expression and uses some default form. It could have printed a + a + a or 3 * a. It sees that it can't further simplify it, because a has no value and thus returns this simplified expression as it is.
In Lisp things are differently. It takes an expression and tries to compute a value:
> (- (* 5 a) (* 2 a))
The result in Lisp is "Error: unbound variable a". It can't compute a value, because during evaluation it sees that the variable a has no value. Evaluation of the unbound variable a is an error.
Now you could write an expression simplifier in Lisp: let's call it simplify. Lisp has a quote operator, which returns the embedded thing as it is -> it is not evaluated. We can embed an expression inside quote and thus call simplify with that unevaluated expression as an argument.
> (simplify (quote (- (* 5 a) (* 2 a))))
The result then could be
(* 3 a)
One then could write a input loop in Lisp
(loop (print (simplify (read)))
which then would not be a read-eval-print-loop, but a read-simplify-print-loop.
This interactive loop would read expressions and print simplified expressions...
Actually something like that has been done with computer algebra systems written in Lisp, like Macsyma/Maxima and Reduce. But they also then switched to infix syntax for input/output to make it easier for humans to enter mathematical expressions.
Peter Norvig gave in his book "Paradigms of AI Programming, Case Studies in Common Lisp" extensive examples how to implement such a thing in Lisp:
The advantage of the Mathematica language compared to Lisp is that it can compute with expressions via rules out of the box. Additionally Mathematica is so much more than that: it is an environment, a collection of mathematical knowledge, a cloud service, a specific product on can buy/rent, ...
The drawback is that the semantics are murky and Mathematica is a two-language system: the fast internal code (and much of the environment) is written in C++ and the expressive language is on top.
Lisp OTOH is often much more efficiently compiled with clear(er) semantics.