transcendental equation solver for solveset: transolve

sympy/solvers/solveset.py

@@ -14,10 +14,12 @@
 from sympy.core.containers import Tuple
 from sympy.core.facts import InconsistentAssumptions
 from sympy.core.numbers import I, Number, Rational, oo
-from sympy.core.function import (Lambda, expand_complex, AppliedUndef, Function)
+from sympy.core.function import (Lambda, expand_complex, AppliedUndef, Function,
+                                expand_log)
 from sympy.core.relational import Eq
 from sympy.core.symbol import Symbol
 from sympy.simplify.simplify import simplify, fraction, trigsimp
+from sympy.simplify import powdenest
 from sympy.functions import (log, Abs, tan, cot, sin, cos, sec, csc, exp,
                              acos, asin, acsc, asec, arg,
                              piecewise_fold, Piecewise)
@@ -30,9 +32,9 @@
 from sympy.sets.sets import Set
 from sympy.matrices import Matrix
 from sympy.polys import (roots, Poly, degree, together, PolynomialError,
-                         RootOf)
+                         RootOf, factor)
 from sympy.solvers.solvers import (checksol, denoms, unrad,
-    _simple_dens, recast_to_symbols)
+    _simple_dens, recast_to_symbols, _ispow)
 from sympy.solvers.polysys import solve_poly_system
 from sympy.solvers.inequalities import solve_univariate_inequality
 from sympy.utilities import filldedent
@@ -943,7 +945,12 @@ def _solveset(f, symbol, domain, _check=False):
                     elif equation.has(Abs):
                         result += _solve_abs(f, symbol, domain)
                     else:
-                        result += _solve_as_rational(equation, symbol, domain)
+                        new_result = _solve_as_rational(equation, symbol, domain)
+                        if isinstance(new_result, ConditionSet):
+                            # may be a transcendental type equation
+                            result += transolve(equation, symbol, domain)
+                        else:
+                            result += new_result
                 else:
                     result += solver(equation, symbol)
 
@@ -978,6 +985,88 @@ def _solveset(f, symbol, domain, _check=False):
     return result
 
 
+def _expo_solver(f, symbol):
+    """
+    Helper function for solving exponential equations.
+
+    This function solves exponential equation by using logarithms.
+    Exponents are converted to a more general form of logs which can further be
+    solved by passing to _solveset.
+    It deals with equations of type `a*f(x) + b*g(x)`, where f(x) and g(x)
+    are power terms.
+
+    eg: 3**(2*x) - 2**(x + 3) can be transformed to a better log form,
+    2*x*log(3) - (x+3)*log(2), which is easily solvable.
+    """
+
+    a, b = ordered(f.args)
+
+    lhs = a
+    rhs = -b
+
+    lhs = expand_log(log(lhs), force=True)
+    rhs = expand_log(log(rhs), force=True)
+
+    return (lhs - rhs)
+
+
+def _check_expo(f, symbol):
+    """
+    Helper to check whether an equation is exponential or not.
+    """
+    try:
+        a, b = ordered(f.args)
+    except ValueError:
+        return False
+
+    ad = a.as_independent(symbol)[1]
+    bd = b.as_independent(symbol)[1]
+
+    return any(_ispow(i) for i in (ad, bd))
+
+
+def transolve(f, symbol, domain, **flags):
+    """Helper for solving transcendental equations."""
+
+    if 'tsolve_saw' not in flags:
+        flags['tsolve_saw'] = []
+    if f in flags['tsolve_saw']:
+        return ConditionSet(symbol, Eq(f, 0), domain)
+    else:
+        flags['tsolve_saw'].append(f)
+
+    inverter = invert_real if domain.is_subset(S.Reals) else invert_complex
+    lhs, rhs_s = inverter(f, 0, symbol, domain)
+
+    result = ConditionSet(symbol, Eq(f, 0), domain)
+
+    if lhs.is_Add:
+        # do we need a loop for rhs?
+        # Can't determine a case as of now.
+        rhs = rhs_s.args[0]
+        equation = factor(powdenest(lhs-rhs))
+
+        if equation.is_Mul:
+            result = _solveset(equation, symbol, domain)
+
+        # check if it is exponential type equation
+        elif _check_expo(equation, symbol):
+            new_f = _expo_solver(equation, symbol)
+            result = _solveset(new_f, symbol, domain)
+
+            if isinstance(result, ConditionSet):
+                result = ConditionSet(symbol, Eq(f, 0), domain)
+
+        else:
+            result = transolve(f, symbol, domain, **flags)
+
+    if lhs.is_Pow:
+        new_f = _expo_solver(lhs, symbol)
+        result = _solveset(new_f, symbol, domain)
+
+    return result
+
+
 def solveset(f, symbol=None, domain=S.Complexes):
     r"""Solves a given inequality or equation with set as output
 

sympy/solvers/tests/test_solveset.py

@@ -1613,9 +1613,9 @@ def test_issue_10555():
     f = Function('f')
     g = Function('g')
     assert solveset(f(x) - pi/2, x, S.Reals) == \
-        ConditionSet(x, Eq(2*f(x) - pi, 0), S.Reals)
+        ConditionSet(x, Eq(f(x) - pi/2, 0), S.Reals)
     assert solveset(f(g(x)) - pi/2, g(x), S.Reals) == \
-        ConditionSet(g(x), Eq(2*f(g(x)) - pi, 0), S.Reals)
+        ConditionSet(g(x), Eq(f(g(x)) - pi/2, 0), S.Reals)
 
 
 def test_issue_8715():
@@ -1749,3 +1749,58 @@ def test_issue_14454():
     number = CRootOf(x**4 + x - 1, 2)
     raises(ValueError, lambda: invert_real(number, 0, x, S.Reals))
     assert invert_real(x**2, number, x, S.Reals)  # no error
+
+
+def test_transolve():
+    from sympy.abc import x, y
+    from sympy.simplify import simplify
+
+    #### exponential equations ####
+
+    e1 = 3**(2*x) - 2**(x + 3)
+    e2 = 4**(5 - 9*x) - 8**(2 - x)
+    e3 = 2**x + 4**x
+    e4 = exp(log(5)*x) - 2**x
+    e5 = x**(y*z) - x     # issue 10864
+    e6 = 5**(x/2) - 2**(x/3)
+    e7 = 2**(x) + 4**(x) + 8**(x) - 84
+    e8 = 4**(x+1) + 4**(x+2) + 4**(x-1) - 3**(x+2) -3**(x+3)
+
+    f1 = exp(x/y)*exp(-z/y) - 2
+    f2 = x**x
+
+    assert solveset(e1, x, S.Reals) == FiniteSet(-3*log(2)/(-2*log(3) + log(2)))
+    assert simplify(solveset(e2, x, S.Reals)) == FiniteSet(4/S(15))
+    assert solveset(e3, x, S.Reals) == S.EmptySet
+    assert solveset(e4, x, S.Reals) == FiniteSet(0)
+    assert solveset(e5, x, S.Reals) == FiniteSet(1)
+    assert solveset(e6, x, S.Reals) == FiniteSet(0)
+    assert simplify(solveset(e7, x, S.Reals)) == FiniteSet(2)
+    assert solveset(e8, x, S.Reals) == FiniteSet(2)
+    assert solveset(f1, x, S.Reals) == Intersection(S.Reals, FiniteSet(y*log(2*exp(z/y))))
+    assert solveset(f2, x, S.Reals) == S.EmptySet
+
+
+def test_expo_conditionset():
+    from sympy.abc import x, y
+
+    f1 = (exp(x) + 1)**x - 2
+    f2 = (x + 2)**y*x - 3
+
+    assert solveset(f1, x, S.Reals) == ConditionSet(x, Eq(log(x) - log(-exp(x) - 1), 0), S.Reals)
+    assert solveset(f2, x ,S.Reals) == ConditionSet(x, Eq(x*(x + 2)**y - 3, 0), S.Reals)
+
+@XFAIL
+def test_expo_fail():
+    from sympy.abc import x, y, z, a, b
+
+    assert solveset(z**x - y, x, S.Reals) == Intersection(S.Reals, FiniteSet(log(y)/log(z)))
+    assert solveset(y - a*x**b, x) == FiniteSet((y/a)**(1/b))
+    assert solveset(Poly(exp(x) + exp(-x) - 4)) == FiniteSet(log(-sqrt(3) + 2), log(sqrt(3) + 2))
+
+    w = symbols('w', integer=True)
+    f1 = 2*x**w - 4*y**w
+    f2 = (x/y)**w - 2
+    ans1 = solveset(f1, w, S.Reals)
+    ans2 = solveset(f2, w, S.Reals)
+    assert ans1 == ans2