mathai 0.7.7__tar.gz → 0.7.9__tar.gz

{mathai-0.7.7 → mathai-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.7.7
+Version: 0.7.9
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Requires-Python: >=3.7

{mathai-0.7.7 → mathai-0.7.9}/mathai/__init__.py

@@ -1,7 +1,7 @@
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 
-from .pde import pde_sep, want
+from .pde import pde_sep, want, absorb
 
 from .linear import linear_solve, linear_or
 
@@ -21,7 +21,7 @@ from .integrate import rm_const as integrate_const
 from .integrate import solve_integrate as integrate_clean
 from .integrate import integrate_formula
 
-from .diff import diff
+from .diff import diff, diff2
 
 from .factor import factor as factor1
 from .factor import factor2, factor3

{mathai-0.7.7 → mathai-0.7.9}/mathai/base.py

@@ -14,7 +14,6 @@ def contains_list_or_neg(node):
     return False
 
 class TreeNode:
-    matmul = None
     
     def __init__(self, name, children=None):
         if children is None:

mathai-0.7.9/mathai/diff.py

@@ -0,0 +1,156 @@
+from .trig import trig0
+from .simplify import simplify
+from .base import *
+
+def helper(eq):
+    name = eq.name
+    if name in ["f_dif", "f_pdif"]:
+        if eq.children[0].name == "f_add":
+            return summation([TreeNode(name, [child, eq.children[1]]) for child in eq.children[0].children])
+        
+        if eq.children[0].name == "f_mul":
+            return summation([product([TreeNode(name, [child, eq.children[1]]) if index==index2 else child for index2, child in enumerate(eq.children[0].children)])\
+                              for index in range(len(eq.children[0].children))])
+        if eq.children[0].name == "f_pow" and "v_" not in str_form(eq.children[0].children[1]):
+            base, power = eq.children[0].children
+            dbase = TreeNode(name, [base, eq.children[1]])
+            b1 = power - tree_form("d_1")
+            bab1 = TreeNode("f_pow", [base, b1])
+            return power * bab1 * dbase
+        
+        if eq.children[0].name == "f_pow":
+            a, b = eq.children
+            return a**b * ((b/a) * TreeNode(name, [a, eq.children[1]]) + a.fx("log") * TreeNode(name, [b, eq.children[1]]))
+
+        if "v_" not in str_form(eq.children[0]):
+            return tree_form("d_0")
+        
+        if eq.children[0] == eq.children[1]:
+            return tree_form("d_1")
+        
+        if name == "f_pdif" and not contain(eq.children[0], eq.children[1]):
+            return tree_form("d_0")
+        if eq.children[0].name == "f_sin":
+            eq.children[0].name = "f_cos"
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d*eq.children[0]
+        if eq.children[0].name == "f_cos":
+            eq.children[0].name = "f_sin"
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return tree_form("d_-1")*d*eq.children[0]
+        if eq.children[0].name == "f_tan":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d/(eq.children[0].children[0].fx("cos")*eq.children[0].children[0].fx("cos"))
+        if eq.children[0].name == "f_log":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d*(tree_form("d_1")/eq.children[0].children[0])
+        if eq.children[0].name == "f_arcsin":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d/(tree_form("d_1")-eq.children[0].children[0]*eq.children[0].children[0])**(tree_form("d_2")**-1)
+        if eq.children[0].name == "f_arccos":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return tree_form("d_-1")*d/(tree_form("d_1")-eq.children[0].children[0]*eq.children[0].children[0])**(tree_form("d_2")**-1)
+        if eq.children[0].name == "f_arctan":
+            d =  TreeNode(name, [eq.children[0].children[0], eq.children[1]])
+            return d/(tree_form("d_1")+eq.children[0].children[0]*eq.children[0].children[0])
+        
+    return eq
+
+def diff3(eq):
+    eq = simplify(eq)
+
+    stack = [(eq, False)]
+    out = {}
+
+    while stack:
+        node, visited = stack.pop()
+
+        if not visited:
+            stack.append((node, True))
+            for c in node.children:
+                stack.append((c, False))
+            continue
+
+        new_children = [out[c] for c in node.children]
+        rebuilt = TreeNode(node.name, new_children)
+        rebuilt = helper(rebuilt)
+        rebuilt = simplify(rebuilt)
+
+        out[node] = rebuilt
+
+    return out[eq]
+
+def diff2(eq):
+    return dowhile(eq, diff3)
+def diff(equation, var="v_0"):
+    def diffeq(eq):
+        eq = simplify(eq)
+        if "v_" not in str_form(eq):
+            return tree_form("d_0")
+        if eq.name == "f_add":
+            add = tree_form("d_0")
+            for child in eq.children:
+                add += diffeq(child)
+            return add
+        elif eq.name == "f_abs":
+            return diffeq(eq.children[0])*eq.children[0]/eq
+        elif eq.name == "f_pow" and eq.children[0].name == "s_e":
+            return diffeq(eq.children[1])*eq
+        elif eq.name == "f_tan":
+            return diffeq(eq.children[0])/(eq.children[0].fx("cos")*eq.children[0].fx("cos"))
+        elif eq.name == "f_log":
+            return diffeq(eq.children[0])*(tree_form("d_1")/eq.children[0])
+        elif eq.name == "f_arcsin":
+            return diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
+        elif eq.name == "f_arccos":
+            return tree_form("d_-1")*diffeq(eq.children[0])/(tree_form("d_1")-eq.children[0]*eq.children[0])**(tree_form("d_2")**-1)
+        elif eq.name == "f_arctan":
+            return diffeq(eq.children[0])/(tree_form("d_1")+eq.children[0]*eq.children[0])
+        elif eq.name == "f_pow" and "v_" in str_form(eq.children[1]):
+            a, b = eq.children
+            return a**b * ((b/a) * diffeq(a) + a.fx("log") * diffeq(b))
+        elif eq.name == "f_mul":
+            add = tree_form("d_0")
+            for i in range(len(eq.children)):
+                tmp = eq.children.pop(i)
+                if len(eq.children)==1:
+                    eq2 = eq.children[0]
+                else:
+                    eq2 = eq
+                add += diffeq(tmp)*eq2
+                eq.children.insert(i, tmp)
+            return add
+        elif eq.name == "f_sin":
+            eq.name = "f_cos"
+            return diffeq(eq.children[0])*eq
+        elif eq.name == "f_cos":
+            eq.name = "f_sin"
+            return tree_form("d_-1")*diffeq(eq.children[0])*eq
+        elif eq.name[:2] == "v_":
+            return TreeNode("f_dif", [eq])
+        elif eq.name == "f_pow" and "v_" not in str_form(eq.children[1]):
+            base, power = eq.children
+            dbase = diffeq(base)
+            b1 = power - tree_form("d_1")
+            bab1 = TreeNode("f_pow", [base, b1])
+            return power * bab1 * dbase
+        return TreeNode("f_dif", [eq, tree_form(var)])
+    def helper2(equation, var="v_0"):
+        if equation.name == "f_dif":
+            if equation.children[0].name == var:
+                return tree_form("d_1")
+            if var not in str_form(equation.children[0]):
+                return tree_form("d_0")
+            else:
+                return equation
+        return TreeNode(equation.name, [helper2(child, var) for child in equation.children])
+    def calc(eq):
+        if eq.name == "f_dif":
+            return diffeq(trig0(eq.children[0]))
+        return TreeNode(eq.name, [calc(child) for child in eq.children])
+    if var is None:
+        return simplify(calc(equation))
+    equation = diffeq(trig0(equation))
+    equation = helper2(equation, var)
+    return simplify(equation)
+

mathai-0.7.9/mathai/fraction.py

@@ -0,0 +1,106 @@
+from .base import *
+from .simplify import simplify
+from .expand import expand
+
+
+def fraction(expr):
+    if expr is None:
+        return None
+    
+    expr = simplify(expr)
+    
+    # -----------------------------
+    # leaf
+    # -----------------------------
+    if expr.children == []:
+        return expr
+
+    # recurse first (inner-most first)
+    children = [fraction(c) for c in expr.children]
+
+    # -----------------------------
+    # ADDITION: collect denominators
+    # -----------------------------
+    if expr.name == "f_add":
+        terms = []
+
+        for c in children:
+            # term is a multiplication
+            if c.name == "f_mul":
+                num = []
+                den = []
+                for f in c.children:
+                    if (
+                        f.name == "f_pow"
+                        and f.children[1].name.startswith("d_")
+                        and int(f.children[1].name[2:]) < 0
+                    ):
+                        n = int(f.children[1].name[2:])
+                        den.append(
+                            f.children[0]
+                            if n == -1
+                            else TreeNode("f_pow", [f.children[0], tree_form(f"d_{-n}")])
+                        )
+                    else:
+                        num.append(f)
+                terms.append((num, den))
+
+            # pure reciprocal
+            elif (
+                c.name == "f_pow"
+                and c.children[1].name.startswith("d_")
+                and int(c.children[1].name[2:]) < 0
+            ):
+                n = int(c.children[1].name[2:])
+                terms.append(([], [
+                    c.children[0]
+                    if n == -1
+                    else TreeNode("f_pow", [c.children[0], tree_form(f"d_{-n}")])
+                ]))
+
+            # normal term
+            else:
+                terms.append(([c], []))
+
+        # if no denominators → rebuild normally
+        if not any(den for _, den in terms):
+            return TreeNode("f_add", children)
+
+        # -----------------------------
+        # build numerator
+        # -----------------------------
+        num_terms = []
+        for i, (num_i, _) in enumerate(terms):
+            acc = list(num_i)
+            for j, (_, den_j) in enumerate(terms):
+                if i != j:
+                    acc += den_j
+            if not acc:
+                acc = [tree_form("d_1")]
+            num_terms.append(
+                acc[0] if len(acc) == 1 else TreeNode("f_mul", acc)
+            )
+
+        numerator = TreeNode("f_add", num_terms)
+
+        # -----------------------------
+        # build denominator
+        # -----------------------------
+        den_all = []
+        for _, den in terms:
+            den_all += den
+
+        denom = den_all[0] if len(den_all) == 1 else TreeNode("f_mul", den_all)
+        denom = TreeNode("f_pow", [denom, tree_form("d_-1")])
+        
+        return simplify(
+            TreeNode(
+                "f_mul",
+                [simplify(expand(numerator)), denom],
+            )
+        )
+
+    # -----------------------------
+    # default reconstruction
+    # -----------------------------
+    return TreeNode(expr.name, children)

{mathai-0.7.7 → mathai-0.7.9}/mathai/integrate.py

@@ -97,6 +97,8 @@ def place_try2(eq):
         return eq.children[try_lst.pop(0)]
     return TreeNode(eq.name, [place_try2(child) for child in eq.children]) 
 def _solve_integrate(eq):
+    if eq is None:
+        return None
     if eq.name == "f_ref":
         return eq
     if eq.name == "f_subs":
@@ -153,14 +155,18 @@ def inteq(eq):
     else:
         return TreeNode(eq.name, [inteq(child) for child in eq.children])
 def rm(eq):
+    if eq is None:
+        return None
     if eq.name == "f_try":
         eq = TreeNode(eq.name, list(set(eq.children)))
     return TreeNode(eq.name, [rm(child) for child in eq.children if child is not None])
 def solve_integrate(eq):
     
     eq2 = dowhile(eq, _solve_integrate)
-    eq2 = dowhile(eq2, handle_try)
+    #eq2 = dowhile(eq2, handle_try)
     eq2 = rm(eq2)
+    if eq2 is None:
+        return None
     if eq2.name == "f_try":
         eq2.children = list(set(eq2.children))
     return eq2
@@ -409,8 +415,8 @@ def integration_formula_ex():
 
 formula_gen11 = integration_formula_ex()
 def rm_const(equation):
-    if equation.name == "f_ref":
-        return equation
+    if equation is None:
+        return None
     eq2 = equation
     if eq2.name == "f_integrate" and contain(eq2.children[0], eq2.children[1]):
         equation = eq2.children[0]
@@ -436,8 +442,8 @@ def shorten(eq):
         return tree_form("d_0")
     return TreeNode(eq.name, [shorten(child) for child in eq.children])
 def integrate_formula(equation):
-    if equation.name == "f_ref":
-        return equation.copy_tree()
+    if equation is None:
+        return None
     eq2 = equation.copy_tree()
     if eq2.name == "f_integrate":
         integrand = eq2.children[0]

mathai-0.7.9/mathai/ode.py

@@ -0,0 +1,326 @@
+import itertools
+from collections import Counter
+from .diff import diff, diff2
+from .factor import factor, factor2, term_common2
+from .expand import expand
+from .base import *
+from .fraction import fraction
+from .simplify import simplify
+import copy
+from .inverse import inverse
+from .parser import parse
+
+def rev(eq):
+    tmp = factor_generation(eq)
+    if tree_form("v_0").fx("dif")**-1 in tmp or tree_form("v_1").fx("dif")**-1 in  tmp:
+        return False
+    for child in eq.children:
+        if not rev(child):
+            return False
+    return True
+node_count = 100
+def kkk(lhs, rhs, depth=5):
+    global node_count
+    lst = [simplify(lhs), simplify(rhs)]
+    orig = copy.deepcopy(lst)
+    if not contain(lst[0], tree_form("v_1")) and not contain(lst[1], tree_form("v_0")):
+        if not contain(lst[0], tree_form("v_0")) and not contain(lst[1], tree_form("v_1")):
+            return lst, False
+        return lst, True
+    node_count -= 1
+    
+    if depth < 0 or node_count < 0:
+        return lst, False
+    for j in range(2):
+        for i in range(2):
+            if lst[i].name in ["f_mul", "f_add"]:
+                for child in lst[i].children:
+                    out = child
+                    if j == 0:
+                        if contain(out, tree_form(f"v_{i}")) or not contain(out, tree_form(f"v_{1-i}")):
+                            continue
+                    if contain(out, tree_form(f"v_{i}")) and not contain(out, tree_form(f"v_{1-i}")):
+                        continue
+                    
+                    if lst[i].name == "f_add":
+                        lst[i] = lst[i] - out
+                        lst[1-i] = lst[1-i] - out
+                    elif lst[i].name == "f_mul":
+                        lst[i] = lst[i] / out
+                        lst[1-i] = lst[1-i] / out
+                    else:
+                        continue
+                    
+                    output = kkk(lst[0], lst[1], depth-1)
+                    lst = orig
+                    
+                    if output[1]:
+                        return output
+                
+    return lst, False
+def clr(eq):
+    return simplify(product([item for item in factor_generation(eq) if "f_add" in str_form(item)]))
+def inversediff(lhs, rhs):
+    global node_count
+    eq = simplify(fraction(TreeNode("f_eq", [lhs-rhs, tree_form("d_0")]))).children[0]
+    eq = simplify(term_common2(eq))
+    eq = clr(eq)
+    
+    out= None
+    if eq.name == "f_add":
+        h = {}
+        n = [eq]
+        for i in range(len(eq.children)-2,1,-1):
+            for item in itertools.combinations(list(range(len(eq.children))), i):
+                item = tuple(sorted(list(item)))
+                tmp = simplify(term_common2(simplify(summation([eq.children[x] for x in item]))))
+                if tmp.name == "f_mul":
+                    h[item] = tmp
+                    
+        for item in itertools.combinations(list(h.keys()),2):
+            
+            g = []
+            for x in item:
+                g += x
+            if sum([len(x) for x in item]) == len(set(g)):
+                pass
+            else:
+                continue
+            
+            item2 = summation([eq.children[x] for x in list(set(range(len(eq.children)))-set(g))])
+            n.append(simplify(term_common2(simplify(h[item[0]] + h[item[1]]))+item2))
+                
+        
+        for item in list(set(n)):
+            
+            item = clr(item)
+            node_count = 100
+            
+            tmp = kkk(item, tree_form("d_0"))
+            
+            if tmp[1]:
+                out = tmp[0]
+                break
+    else:
+        node_count = 100
+        tmp = kkk(eq, tree_form("d_0"))
+        if tmp[1]:
+            out = tmp[0]
+    if out is None:
+        return None
+    out = [simplify(fraction(item)) for item in out]
+    
+    if not rev(out[0]) and not rev(out[1]):
+        
+        out[0] = fraction(1/out[0])
+        out[1] = fraction(1/out[1])
+    return simplify(e0(out[0]-out[1]))
+
+def allocvar():
+    return tree_form("v_101")
+
+def epowersplit(eq):
+    if eq.name == "f_pow" and eq.children[1].name == "f_add":
+        return product([eq.children[0]**child for child in eq.children[1].children])
+    return TreeNode(eq.name, [epowersplit(child) for child in eq.children])
+def esolve(s):
+    if s.name == "f_add" and "f_log" in str_form(s):
+        return product([tree_form("s_e")**child for child in s.children]) - tree_form("d_1")
+    return TreeNode(s.name, [esolve(child) for child in s.children])
+def diffsolve_sep2(eq):
+    lst = None
+    if eq is None:
+        return None
+    eq = eq.children[0]
+    if eq.name == "f_add":
+        lst = list(eq.children)
+    else:
+        lst = [eq]
+    s = [allocvar()]
+    
+    for item in lst:
+        item = simplify(item)
+        tmp = factor_generation(item)
+        
+        tmp2 = product([k for k in tmp if k.name != "f_dif"])
+        
+        if tree_form("v_0").fx("dif") in tmp:
+            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_0")]))
+        elif tree_form("v_1").fx("dif") in tmp:
+            s.append(TreeNode("f_integrate", [tmp2, tree_form("v_1")]))
+    
+    return TreeNode("f_eq", [summation(s), tree_form("d_0")])
+def e0(eq):
+    return TreeNode("f_eq", [eq, tree_form("d_0")])
+def e1(eq):
+    if eq.name == "f_eq":
+        eq = eq.children[0]
+    return eq
+def groupe(eq):
+    eq = esolve(eq)
+    eq = simplify(eq)
+    eq = fraction(eq)
+    eq = simplify(eq)
+    eq = epowersplit(eq)
+    return eq
+
+def diffsolve_sep(eq):
+    eq = epowersplit(eq)
+    
+    eq = inversediff(tree_form("d_0"), eq.children[0].copy_tree())
+    
+    return eq
+
+def diffsolve(eq):
+    orig = eq.copy_tree()
+    eq = diff2(eq)
+    eq = subs2(eq, order(eq))
+    eq = fraction(simplify(fraction(eq)))
+    
+    if order(eq) == 2:
+        for i in range(2):
+            out = second_order_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
+            if out is not None:
+                return out
+        return orig
+    
+    eq = diffsolve_sep2(diffsolve_sep(eq))
+    
+    if eq is None:
+        for i in range(2):
+            a = tree_form(f"v_{i}")
+            b = tree_form(f"v_{1-i}")
+            c = tree_form("v_2")
+            eq2 = orig
+            
+            eq2 = subs2(eq2, 1)
+            eq2 = replace(eq2, b, b*a)
+            eq2 = subs3(eq2)
+            
+            eq2 = simplify(fraction(simplify(eq2)))
+            
+            eq2 = diffsolve_sep(eq2)
+            
+            eq2 = diffsolve_sep2(eq2)
+            if eq2 is not None:
+                return e0(TreeNode("f_subs", [replace(eq2.children[0],b,c), c,b/a]).fx("try"))
+        eq = orig
+        eq = simplify(eq)
+        eq = subs2(eq, 1)
+        eq = fraction(eq)
+        for i in range(2):
+            
+            out = linear_dif(eq, tree_form(f"v_{i}"), tree_form(f"v_{1-i}"))
+            if out is not None:
+                return out
+        return orig
+    else:
+        return eq
+
+def clist(x):
+    return list(x.elements())
+def collect_term(eq, term_lst):
+    
+    lst = None
+    if eq.name == "f_add":
+        lst = copy.deepcopy(eq.children)
+    else:
+        lst = [eq]
+        
+    other = []
+    dic = {}
+    term_lst = list(sorted(term_lst, key=lambda x: -len(factor_generation(x))))
+    for item in term_lst:
+        dic[item] = tree_form("d_0")
+    for item2 in lst:
+        done = True
+        tmp2 = Counter(factor_generation(item2))
+        for index, item in enumerate(term_lst):
+            
+            tmp = Counter(factor_generation(item))
+            
+            if (tmp2&tmp) == tmp:
+                if item in dic.keys():
+                    
+                    dic[item] += product(clist(tmp2-tmp))
+                else:
+                    
+                    dic[item] = product(clist(tmp2-tmp))
+                done = False
+                break
+        if done:
+            other.append(item2)
+    other = summation(other)
+    
+    for key in dic.keys():
+        dic[key] = simplify(dic[key])
+    return [dic, simplify(other)]
+def order(eq,m=0):
+    best = m
+    if eq.name in ["f_pdif", "f_dif"]:
+        out = order(eq.children[0], m+1)
+        best = max(out, best)
+    else:
+        for child in eq.children:
+            out = order(child, m)
+            best = max(out, best)
+    return best
+def subs2(eq, orde):
+    if eq.name in ["f_dif", "f_pdif"] and len(eq.children) == 2:
+        if orde == 1:
+            return eq.children[0].fx("dif")/eq.children[1].fx("dif")
+        else:
+            return subs2(TreeNode("f_dif", eq.children), orde)
+    return TreeNode(eq.name, [subs2(child, orde) for child in eq.children])
+def subs3(eq):
+    if eq.name == "f_dif" and eq.children[0].name == "f_add":
+        return summation([subs3(child.fx("dif")) for child in eq.children[0].children])
+    if eq.name == "f_dif" and eq.children[0].name == "f_mul":
+        return summation([product([subs3(child.fx("dif")) if index==index2 else child for index2, child in enumerate(eq.children[0].children)]) for index in range(len(eq.children[0].children))])
+    return TreeNode(eq.name, [subs3(child) for child in eq.children])
+def second_order_dif(eq, a, b):
+    eq = simplify(eq)
+    nn = [TreeNode("f_dif", [TreeNode("f_dif", [b,a]),a]), TreeNode("f_dif", [b,a]), b]
+    out = collect_term(eq.children[0], nn)
+    if out[1] == tree_form("d_0"):
+        tmp = out[0][nn[0]]
+        if tmp != tree_form("d_0"):
+            for key in out[0].keys():
+                out[0][key] = simplify(out[0][key]/tmp)
+                
+            B = out[0][nn[1]]
+            C = out[0][nn[2]]
+            
+            if all(all(not contain(item, item2) for item2 in [a,b]) for item in [B, C]):
+                r = parse("r")
+                s = simplify(factor2(simplify(TreeNode("f_eq", [r**2 + B*r + C, tree_form("d_0")])), True))
+                r1, r2 = [inverse(item, r.name) for item in s.children[0].children]
+                out = None
+                if contain(r1, tree_form("s_i")):
+                    real = simplify(fraction((r1+r2)/tree_form("d_2")))
+                    imagine = simplify((r1-real)/tree_form("s_i"))
+                    out = tree_form("s_e")**(real*a)*(tree_form("v_101")*(imagine*a).fx("cos")+tree_form("v_102")*(imagine*a).fx("sin"))
+                elif fraction(simplify(r1-r2)) == tree_form("d_0"):
+                    out =(tree_form("v_101")+tree_form("v_102")*a)*tree_form("s_e")**(r1*a)
+                else:
+                    out = tree_form("v_101")*tree_form("s_e")**(r1*a) + tree_form("v_102")*tree_form("s_e")**(r2*a)
+                return TreeNode("f_eq", [b, out])
+    return None
+                
+def linear_dif(eq, a, b):
+    eq = simplify(eq)
+    
+    out = collect_term(eq.children[0], [b.fx("dif"), b*a.fx("dif"), a.fx("dif")])
+    
+    if out[1] == tree_form("d_0"):
+        tmp = out[0][b.fx("dif")]
+        if tmp != tree_form("d_0"):
+            
+            for key in out[0].keys():
+                out[0][key] = simplify(out[0][key]/tmp)
+            p, q = out[0][b*a.fx("dif")], -out[0][a.fx("dif")]
+            if contain(p, b) or contain(q, b):
+                return None
+            f = tree_form("s_e") ** TreeNode("f_integrate", [p, a])
+            return simplify(TreeNode("f_eq", [b*f, TreeNode("f_integrate", [q*f, a])+allocvar()]))
+    return None