Basically, trace$ calls on the underlying Lisp to trace the specified
functions as well as their executable-counterparts. However, for GCL,
Allegro CL, and OpenMCL, the underlying Lisp trace routines are modified
before an image is saved in order to hide the ACL2 world and other large data
structures and provide slightly prettier output.

Recursive calls of functions whose guards have not been verified will
not generally be traced. If you want to see traces for corresponding
evaluations in raw Lisp, which will generally show recursive calls (except,
in some Lisp implementations, for compiled tail recursive functions), then
you can quit into raw Lisp (:q) and execute your form there.
Alternatively, you can avoid executable-counterpart functions by using
:set-raw-mode to enter a raw Lisp version of the ACL2 loop;
see set-raw-mode and see set-raw-mode-on!.

Also see wet (``with-error-trace'') for a different way that ACL2
takes advantage of the underlying Lisp, namely to provide a backtrace when
there is an error.

Note that from a logical perspective all trace printing is a fiction. For a
related fiction, see cw. Trace$ returns nil.

The following example will give an idea of the options available other than
just (trace$ fn1 fn2 ... fnk). It works about as shown in Allegro CL and
GCL, but in OpenMCL the recursive calls are omitted unless you escape into
raw Lisp and redefine fact with (declare (notinline fact)).

The admission of FACT2 is trivial, using the relation O< (which is
known to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT N). We observe that the type of FACT2 is described by
the theorem (AND (CONSP (FACT2 N ACC)) (TRUE-LISTP (FACT2 N ACC))).
We used primitive type reasoning.

(FACT2 * *) => (MV * *).

The guard conjecture for FACT2 is trivial to prove. FACT2 is compliant
with Common Lisp.