Here's a general workflow for blocking values of global variables while output is prepared. Before the output is returned, the global variables need to be protected from evaluation. HoldForm is the way to do this and have the variables be typeset in their usual format.

x = 3; y = 7; (* to see if x appears as x *)

(** hold variables to be used in formula/output **)
heldvars = Hold[x, y];
(* use stored variables in heldvars to Block their values *)
heldvars /. Hold[$v___] :> Block[{$v, res},
   (** possibly lengthy code to compute result `res` **)
   res = Column[{x''[t]/Sqrt[x + y] == 5 y}, Spacings -> 0.5];
   (* protect variables with HoldForm before returning *)
   res = res /. {var : Alternatives[$v] :> HoldForm[var]};
   (** format result **)
   TextCell[
    TraditionalForm@res,
    "Text", FontFamily -> "Palatino", FontSize -> 18]
   ]

The lines of code after the comments between the double asterisks (**...**) are user-supplied and would probably change from case to case. The lines of code after the comments between the single asterisks (*...*) should be the same in all use-cases (that I've thought of). One exception might be whether to block the variable res. It might be left global or it might be localized in a Module instead of in Block. Similarly, but more importantly, you shouldn't use $v as a variable in the computation of res, since it was used as a pattern name.

You also don’t need the Block, as I’ve been trying to explain to the OP:

ToString[Unevaluated[x''[t]/Sqrt[x + y] == 5 y ], 
     TraditionalForm]

The OP seems to very much want to deal with cells and boxes for some reason.

Ernesto,

I think what you want is to do something like this:

Block[{x}, 
 TraditionalForm@
  TextCell[
   Column[{Row[{ToString[x, TraditionalForm], " = ", 
       5}]    (*I want x to always be a symbol*)}, Spacings -> 0.5], 
   "Text", FontFamily -> "Palatino", FontSize -> 18]]

You can see what the problem is by looking at the FullForm of your expression returned from the Block:

blk = Block[{x}, 
   TraditionalForm@
    TextCell[
     Column[{Row[{x, " = ", 
         5}]    (*I want x to always be a symbol*)}, Spacings -> 0.5],
      "Text", FontFamily -> "Palatino", FontSize -> 18]];

blk // FullForm

The Block clears the local value of x so it can be used as a symbol or reassigned locally as you want to do. However, after it is returned to the front end, it still has the variable form of x inside. This causes Mathematica to reevaluate it in the global context and substitute the value for x. The way to fix this is to "lock down" the symbol x so it doesn't get reevaluated. Since you only seem to want a string in the end that has the traditional form of the variable, I would use the local value of x (a symbol) and convert it to a string in traditional form. At this point it will no longer be reevaluated.

I hope this helps,

Neil

Another question:

• Are you familiar with how to use style sheets?

Here is an example of my code. (Eric.nb)

What I want as result (Test.nb]

Attachments:

Eric.nb

Test.nb

Eric: “If the variable definitions in the Block have no OwnValues, then they are treated as symbols.”

This is valid if x is not global with value.

“You can use a string, or you can wrap the symbol in HoldForm. Why would that not work in your case? Also, SymbolName might be a cleaner way to generate a string from the symbol.”

I have at least 20 lines of code inside each Block that contain many mathematical symbols and I want them not to be evaluated if they are global, since they are use in expressions to read not to evaluate. I have hundreds of Blocks to use HoldForm or SymbolName. It would leave my code unreadable. I cannot use strings because the format of the variables is lost. My suggestion is that if x is a Block local variable and no value is assigned to it, this variable is treated as a symbol.

Ernesto

I appreciate your attention and kindness.

If in a Block its local variables have no value, I don't understand why they are not treated as symbols.

If the variable definitions in the Block have no OwnValues, then they are treated as symbols. This has nothing to do with Block. The problem is that the expression you're creating inside the Block will be outside the Block once the Block is done. Once it's outside the Block, the evaluator continues to do its evaluating, and when it sees the x it will look for OwnValues for that x.

If you're not going to need to evaluate/manipulate the expression later, then you don't need a raw symbol. You can use a string, or you can wrap the symbol in HoldForm. Why would that not work in your case?

Also, SymbolName might be a cleaner way to generate a string from the symbol.

cross-posted here: https://mathematica.stackexchange.com/questions/269308/trouble-understanding-the-local-variables-of-the-block-command