rewriting negative powers

Question

I often run into the problem that Mathematica refuses to simplify divergent subexpressions as part of a full expression that is manifestly finite. This only happens when a symbolic power is involved.

A minimal example is:

expr = x^(d - 4) (a x^2 + b (x + x^3 + c x^d));

Let's say this is an expression that I want to use for all d>=3. Then d=3 comes closest to diverging:

Series[expr/.d->3,{x,0,0}]

gives b, ofcourse.

But I want to be able to do this:

expr /. d->3 /.x->0

which in its current form will run into a division by zero.

Note that if we simplify the expression after setting d->3 it does work, but that is not what I'm after.

I have at various times made some ad hoc solution with a replacement rule for example, but I've run into this problem so often now that I'm looking for a definite general solution.

You may assume that the expression is rational in x, that the expression when properly expanded is finite and nonzero at x=x0 (in the example above x0=0), and that there is some definite lower bound for the symbolic power (d above).

I'm ideally looking for a simple and reasonably fast solution that works for any expression satisfying the above criteria.

EDIT: Something like Expand[expr] would work, but I want something more sensible, keeping the expression as much as possible in simplified form.

Answer 1

Apart may be what you want. In the case of expr, it appropriately collects the powers of x so that they do not diverge at d->3.

Apart[expr]

b c x^(-4 + 2 d) + x^(-3+d) (b + a x + b x^2)

This does not increase the expression's complexity much, and gives the appropriate results after substitution:

Apart[expr] /. d -> 3

b + a x + b x^2 + b c x^2

Apart[expr] /. d -> 3 /. x -> 0

b

Apart is usually reasonably fast, and I'm not convinced there is a simpler way to manage the particular expression in Mathematica besides, conceptually, Limit. Its usual purpose is in rewriting rational expressions, such as these, to minimize (or in this case mostly eliminate) the denominators.

Answer 2

I found one way to automate what you would do yourself, ending up with an expression very close to the original:

You apply this function:

regulateExpression[expr,x,d->3]

where the function is this:

regulateExpression[expr_, x_, repl_] := expr /. x^p_ factor_ /; (p < 0/. repl) :> 
decreasePower[factor, x, -p, repl]

This finds the problematic powers (those that can become negative), removes them and applies decreasePower to the expression that multiplies that power.

The function that does the work is decreasePower. It's rather lengthy, but it basically just encodes the mathematical identities regarding powers.

The first argument is the expression it's applied to, the second the variable, the third the power of that variable by which it should be divided, and the fourth the replacement rule that sets the minimum value of the parameter occurring in the powers (d in the question).

decreasePower[(a_ : 1) x_^(q_ : 1), x_, n_, repl_] /; (q >= n /. repl) := a x^(q - n)
decreasePower[a_, x_, 0, repl_] := a
decreasePower[a_ + b_, params__] := decreasePower[a, params] + decreasePower[b, params]
decreasePower[a_^p_, x_, n_, repl_] := decreasePower[a, x, n/p, repl]^p
decreasePower[a_*b_, x_, n_, repl_] /; FreeQ[a, x] := a decreasePower[b, x, n, repl]
decreasePower[a_*b_, x_, n_, repl_] /; (0 == a /. repl /. x -> 0) := decreasePower[decreasePower[a, x, 1, repl] b, x, n - 1, repl]

This works for my current cases, I'm not sure how general it is beyond that, but I'll update if I have any improvements.