# How to prevent Mathematica from complete evaluation of special functions?

Recently I tried to check a result of integration which should be a linear combination of the Riemann $\zeta\;$-function at various arguments, the coefficients of the combination being of primary interest.

Unfortunately Mathematica have expanded all occurrences of $\zeta\;$-functions with even integer arguments.

Is there a way to prevent it from doing that?

A sample code:

 Integrate[ Log[1-x]^5/x^5, {x, 0, 1}]


This is even simpler (thanks to @CarlWoll):

ClearSystemCache[];
Block[{Zeta = Inactive[Zeta]},
Integrate[Log[1 - x]^5/x^5, {x, 0, 1}]]


Using the Gayley-Villegas trick:

InternalInheritedBlock[{Zeta},
Unprotect[Zeta];
Zeta[a_Integer /; a > 1] /; ! TrueQ[$in] := Block[{$in = True},
Inactive[Zeta][a]
];
Protect[Zeta];
Integrate[Log[1 - x]^5/x^5, {x, 0, 1}]
]


Note: The integral is actually computed in terms of limits of an expression involving PolyLog[n, 1-x] (for n = 2,3,4,5); we could do something similar for PolyLog as was done for Zeta above. However PolyLog actually evaluates to Zeta first, which is why the above works in this case. I mention it in case PolyLog does not evaluate to Zeta in a future version. And it's possible the integral will not be computed in terms of PolyLog in the future, too, I suppose. In any case, I thought some explanation of why the code happens to work in this case would be helpful. (It will certainly help me a year from now when someone asks why this doesn't work, and I won't remember a thing about it.)

• Simpler is ClearSystemCache[]; Block[{Zeta = Inactive[Zeta]}, Integrate[Log[1 - x]^5/x^5, {x, 0, 1}]]. I tried using this Block earlier and it didn't work. When I saw your answer, I realized that the cache was interfering. Apr 14, 2018 at 15:50
• @CarlWoll Ditto for me. But I didn't realize the cache was causing the problem, even though I mentioned it to the OP. (Ha-ha). Thanks. Apr 14, 2018 at 15:55
• After my comment, I read the comments to the OP, and saw that! lol Apr 14, 2018 at 15:59
• @MichaelE2 This is a nice suggestion, however I would like to recognise when it's superior over a simple pattern matching approach. +1. Apr 14, 2018 at 16:35
• @Artes This fiddling with the internals slows down Integrate, even worse if we inactivate PolyLog in the same way. Makes me wonder how safe it is. In fact, I got a wrong answer with one thing I tried (not shown). On the other hand, pattern matching can be made much harder if there are coefficients in the integrand that obfuscate or destroy the pattern. But done your way, it is perfectly safe. (+1 to your answer a while ago.) Apr 14, 2018 at 17:49

Mathematica is a term rewriting system and there are various ways to suppress automatic evaluation of expressions. The system doesn't evaluate Zeta for odd integer arguments (see e.g. Zeta[Range[2, 20]]). Zeta[n] yields expressions involving n-th powers of Pi, thus one of possible ways to achieve the goal would be e.g.

Integrate[Log[1 - x]^5/x^5, {x, 0, 1}] /.
Times[x_, Pi^n_Integer] :> x Pi^n Inactivate[Zeta[n]]/Zeta[n] //


Another way is to use HoldForm[Zeta[n]] instead of Inactivate[Zeta[n]] however the latter is more universal and handy. You can use Activate (also with appropriate patterns) to evaluate the expression, e.g.

Activate[%]

-((5 Pi^2)/6) - (11 Pi^4)/18 - 30 (Zeta[3] + Zeta[5])


Nevertheless using such a replacement should be appropriately restricted to avoid possible ambiguities with expressions involving symbolic results in terms of powers of Pi.

• For safety, you can restrict the transformation to even powers of $\pi$: Times[x_, π^n_?EvenQ] Apr 13, 2018 at 18:11
• @J.M.needshelp. Right, however the OP might explain if expressions like e.g. Integrate[BesselK[0, x]^2, {x, 0, Infinity}] are subject to transform or not. Apr 13, 2018 at 18:23
• Thanks for the answer. However we are just lucky that in this special case we can recognize our function by a power of $\pi$. It may be however a more general function with a "simple" value at a special point. Is there a general way to prevent Mathematica from evaluation of some listed functions?
– drer
Apr 13, 2018 at 19:57
• @drer I've mentioned about pattern option in Inactivate which could be exploited. With an example at hand this could be worked out, nonetheless there is no obvious general way. Apr 13, 2018 at 20:21
• @drer Re "in this special case we can recognize our function by a power of π": It's not clear that it is because Zeta is evaluating that we have powers of π in the answer. Executing Block[{Zeta = Inactive[Zeta]}, Integrate[Log[1 - x]^5/x^5, {x, 0, 1}]] suggests that the powers of π are computed without using Zeta`. If so, one cannot blame the evaluation of special functions for returning a correct answer in a certain form. Apr 14, 2018 at 1:41