Limit of $a^x$ when $x\rightarrow\infty$ does not output all conditional solutions depending on parameter $a$

Question

I'm trying to compute the limit $\lim_{x\rightarrow \infty}a^x$ for $a>0$ in Mathematica and I would want it to give me the conditional solutions depending on the value of the paramter $a$. However, when I input

Limit[a^x, x -> ∞, Assumptions -> a > 0, 
 GenerateConditions -> True]

the output is

ConditionalExpression[∞, Log[a] > 0]

That is, it is only considering the case when $a>1$, but not the cases when $0<a<1$ or $a=1$, which should yield $0$ and $1$, respectively. I've tried to look at the documentation pages, but the only option that I have found related to conditions for the parameters is GenerateConditions->True, but it doesn't work with that.

Answer 1

No one asked for a workaround, so maybe the bad news that Limit does not do what the OP wants is enough. But here's a workaround:

repl = {dom_ /; ! TrueQ@Not@dom :> (
     Limit[a^x, x -> \[Infinity],
      Assumptions -> dom, GenerateConditions -> True] /. {
       ConditionalExpression[r1_, d1_] :> (
         Sow[{r1, Reduce[dom && d1]}];
         Reduce[dom && Not[d1]]), (* subtract the condition d1 from the domain *)
       _Limit :> (
         Sow[{Undefined, True}];
         False),                  (* no solution: we're done *)
       r1_ :> (
         Sow[{r1, dom}];
         False)                   (* unconditional solution: we're done *)
       }
     )
   };

a > 0 //  (* starting domain *)
    (Sow[{Undefined, ! #}]; #) & // (* optional *)
   ReplaceRepeated@repl // Reap //
 Replace@{{_, {pw_}} :> Piecewise[pw]}
(*
ConditionalExpression[
 Piecewise[{
   {Infinity, a > 1},
   {0, 0 < a < 1},
   {1, a == 1}}, 0],
 a > 0]
*)

Removing the optional line yields just the piecewise expression.

I've said elsewhere that Assumptions are logically distinct from constraints ($A \Rightarrow X$ versus $A \wedge X$, respectively), though often the distinction is hard to see in the computed results, because a solution that satisfies $A \wedge X$ automatically satisfies $A \Rightarrow X$. It may be in some cases, the above won't work with Limit; however it works in the case at hand.

Answer 2

Here's a piece of code that might work. It definitely works for this case; who knows how well it will work for others. Basically, recurselimit runs Limit on your expression (with GenerateConditions -> True) and checks to see if a ConditionalExpression was generated. If it was, it runs Limit again with Not[condition] appended to your list of original assumptions. If the result of Limit was not a ConditionalExpression, the limit is true regardless of the remaining assumptions, and we exit the recursion. At each stage, the value of the limit and the conditions attached to it are seeded using Sow, and then the Reap at the end collects them and puts them into a Piecewise function.

This was my first time seriously using Sow and Reap in Mathematica, so there are probably more elegant ways of doing what I've done here. Still, it was fun.

recurselimit[expr_, limit_Rule, Assumptions -> assum_, ___] :=
 (partiallimit = Limit[expr, limit, Assumptions -> assum, GenerateConditions -> True];
   If[!(Head[partiallimit] === ConditionalExpression),
     Sow[{partiallimit, Reduce[assum]}],
     Sow[{partiallimit[[1]], Reduce[assum && partiallimit[[2]]]}]; 
     recurselimit[expr, limit, Assumptions -> And[assum, ! partiallimit[[2]]]]]
  )
Reap[recurselimit[a^x, x -> \[Infinity], Assumptions -> a > 0]];
Piecewise[First[%[[2]]],Null]