mathai 0.4.0__py3-none-any.whl → 0.6.9__py3-none-any.whl

mathai/structure.py

@@ -1,5 +1,5 @@
 import itertools
-from .simplify import solve, simplify
+from .simplify import simplify
 from .base import *
 
 def structure(equation, formula, formula_out=None, only_const=False):
@@ -84,7 +84,7 @@ def transform_formula(equation, wrt, formula_list, var, expr):
                 for j in range(len(expr)):
                     item[i] = replace(item[i], expr[j][0], item2[j])
             for i in range(2):
-                item[i] = solve(item[i])
+                item[i] = simplify(item[i])
             out = None
             p = False
             if var != "":

mathai/tool.py

@@ -4,6 +4,102 @@ from .simplify import simplify
 from .base import *
 import math
 
+def poly_div(dividend_coeffs, divisor_coeffs):
+    """
+    Perform polynomial division using coefficients with symbolic simplification.
+    """
+    # Deep copy inputs using copy_tree()
+    dividend = [item.copy_tree() for item in dividend_coeffs]
+    divisor = [item.copy_tree() for item in divisor_coeffs]
+    
+    # Remove leading zeros
+    while len(dividend) > 1 and simplify(dividend[0]) == 0:
+        dividend.pop(0)
+    while len(divisor) > 1 and simplify(divisor[0]) == 0:
+        divisor.pop(0)
+    
+    # Validate divisor
+    if len(divisor) == 0 or simplify(divisor[0]) == 0:
+        raise ValueError("Invalid divisor")
+    
+    if len(dividend) < len(divisor):
+        return [tree_form("d_0")], [item.copy_tree() for item in dividend]
+    
+    # Calculate degrees
+    deg_p = len(dividend) - 1
+    deg_q = len(divisor) - 1
+    deg_quot = deg_p - deg_q
+    
+    # Initialize quotient (highest degree first)
+    quotient = [tree_form("d_0")] * (deg_quot + 1)
+    
+    # Working dividend - keep original structure
+    working_dividend = [item.copy_tree() for item in dividend]
+    
+    # Long division - align by current leading terms
+    for k in range(deg_quot, -1, -1):
+        # Remove leading zeros from working dividend
+        while len(working_dividend) > 1 and simplify(working_dividend[0]) == 0:
+            working_dividend.pop(0)
+        
+        if len(working_dividend) == 0 or simplify(working_dividend[0]) == 0:
+            continue
+        
+        # Calculate quotient term for degree k
+        leading_ratio = simplify(working_dividend[0] / divisor[0])
+        quotient[k] = leading_ratio
+        
+        # Subtract leading_ratio * divisor (aligned at leading terms)
+        new_dividend = []
+        for i in range(max(len(working_dividend), len(divisor))):
+            dividend_term = working_dividend[i] if i < len(working_dividend) else tree_form("d_0")
+            divisor_term = simplify(leading_ratio * divisor[i]) if i < len(divisor) else tree_form("d_0")
+            result = simplify(dividend_term - divisor_term)
+            new_dividend.append(result)
+        
+        working_dividend = new_dividend
+    
+    # Remainder is terms with degree < deg_q (last deg_q terms of final dividend)
+    remainder = working_dividend[-(deg_q):] if len(working_dividend) > deg_q else working_dividend
+    while len(remainder) > 1 and simplify(remainder[0]) == 0:
+        remainder.pop(0)
+    if not remainder:
+        remainder = [tree_form("d_0")]
+    
+    # Clean quotient trailing zeros
+    while len(quotient) > 1 and simplify(quotient[-1]) == 0:
+        quotient.pop()
+    
+    return quotient, remainder
+
+def unpoly(eq, var):
+    eq = eq[::-1]
+    eq = [simplify(item) for item in eq]
+    eq2 = copy.deepcopy([eq[i]*tree_form(var)**tree_form("d_"+str(i)) if i != 0 else eq[i] for i in range(len(eq))])
+    return summation(eq2)
+
+def longdiv(p, q, p_min=0, q_min=0):
+    p, q = simplify(p), simplify(q)
+    
+    var = set(vlist(p)) & set(vlist(q))
+    if len(var) > 0:
+        var = list(var)[0]
+        p = poly(p, var)
+        q = poly(q, var)
+        if p is not None and q is not None and len(p)-1>=p_min and len(q)-1>=q_min and len(p)<=len(q):
+            a, b = poly_div(p, q)
+            return unpoly(a, var), unpoly(b, var)
+    return None
+def poly_simplify(eq):
+    a, b = num_dem(eq)
+    b = simplify(b)
+    if b != 1:
+        return simplify(poly_simplify(a)/poly_simplify(b))
+    for var in vlist(eq):
+        n = poly(eq, var, 20)
+        if n is not None:
+            return simplify(unpoly(n, var))
+    return TreeNode(eq.name, [poly_simplify(child) for child in eq.children])
 def enclose_const(eq):
     def req(eq, dic):
         for key in dic.keys():
@@ -31,12 +127,17 @@ def enclose_const(eq):
     eq= helper(eq)
     return eq, lambda x: req(x, dic)
 
-def poly(eq, to_compute):
+def poly(eq, to_compute, m=10):
     def substitute_val(eq, val, var="v_0"):
         eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
         return eq
     def inv(eq):
-        if eq.name == "f_pow" and "v_" in str_form(eq.children[0]) and eq.children[1] == tree_form("d_-1"):
+        if eq.name[:2] == "f_" and eq.name[2:] in "ref try integrate subs".split(" "):
+            return False
+        if eq.name[2:] in ["sin", "cos", "log"] and contain(eq.children[0], tree_form(to_compute)):
+            return False
+        if eq.name == "f_pow" and contain(eq.children[0], tree_form(to_compute)) and\
+           (frac(eq.children[1]) is None or frac(eq.children[1]) < 0 or frac(eq.children[1]).denominator != 1):
             return False
         if eq.name == "f_abs":
             return False
@@ -47,7 +148,7 @@ def poly(eq, to_compute):
         return None
     out = []
     eq2 = eq
-    for i in range(10):
+    for i in range(m):
         out.append(expand(simplify(eq2)))
         eq2 = diff(eq2, to_compute)
     for i in range(len(out)-1,-1,-1):
@@ -58,5 +159,5 @@ def poly(eq, to_compute):
     final = []
     for index, item in enumerate(out):
         final.append(substitute_val(item, 0, to_compute)/tree_form("d_"+str(math.factorial(index))))
-        
+
     return [expand(simplify(item)) for item in final][::-1]

mathai/trig.py

@@ -1,5 +1,5 @@
 import itertools
-from .simplify import solve, simplify
+from .simplify import simplify
 from .base import *
 from .expand import expand
 from .structure import transform_formula
@@ -49,7 +49,7 @@ def trig0(eq):
                 count += 1
         if count != 1:
             return None
-        eq = solve(product(lst)/tree_form("s_pi"))
+        eq = simplify(product(lst)/tree_form("s_pi"))
         out = frac(eq)
         if out is None or out < 0:
             return None
@@ -58,6 +58,9 @@ def trig0(eq):
         if a > b:       
             a = 2*b - a
         return a, b
+    if eq.name == "f_arccosec":
+        return (1/eq.children[0]).fx("arcsin")
+    
     if eq.name == "f_arctan":
         if eq.children[0].name == "d_0":
             return tree_form("d_0")
@@ -82,7 +85,7 @@ def trig0(eq):
         if any(isneg(item) for item in lst):
             return -(eq.children[0]*-1).fx("sin")
         out=single_pi(lst)
-        if out is not None:
+        if out is not None and tuple(out) in trig_sin_table.keys():
             return trig_sin_table[tuple(out)]
     
     if eq.name == "f_cos":
@@ -96,31 +99,48 @@ def trig0(eq):
             if tuple(out) in trig_cos_table.keys():
                 return trig_cos_table[tuple(out)]
     return TreeNode(eq.name, [trig0(child) for child in eq.children])
+def cog(expr):
+    expr = TreeNode(expr.name, [product_to_sum(child) for child in expr.children])
+    expr = trig0(simplify(expr))
+    expr = expand(simplify(expr))
+    return expr
+def product_to_sum(expr):
+    factors = factor_generation(expr)
+    other = []
+    lst = []
+    for item in factors:
+        if item.name in ["f_cos", "f_sin"]:
+            lst.append(item)
+        else:
+            other.append(item)
+    if len(lst) <= 1:
 
-def product_to_sum(eq):
-    lst = factor_generation(eq)
-    if len(lst) == 1:
-        return lst[0]
+        return dowhile(expr, cog)
     if len(lst) == 2:
         a, b = lst
+        out = None
+        if a.name < b.name:
+            a, b = b, a
+        A, B = a.children[0], b.children[0]
         if a.name == "f_sin" and b.name == "f_sin":
-            return ((a.children[0] - b.children[0]).fx("cos") - (a.children[0] + b.children[0]).fx("cos")) / tree_form("d_2")
+            out =((A - B).fx("cos") - (A + B).fx("cos")) / tree_form("d_2")
         elif a.name == "f_cos" and b.name == "f_cos":
-            return ((a.children[0] - b.children[0]).fx("cos") + (a.children[0] + b.children[0]).fx("cos")) / tree_form("d_2")
+            out =((A - B).fx("cos") + (A + B).fx("cos")) / tree_form("d_2")
         elif a.name == "f_sin" and b.name == "f_cos":
-            return ((a.children[0] + b.children[0]).fx("sin") + (a.children[0] - b.children[0]).fx("sin")) / tree_form("d_2")
-        elif a.name == "f_cos" and b.name == "f_sin":
-            return ((a.children[0] + b.children[0]).fx("sin") - (a.children[0] - b.children[0]).fx("sin")) / tree_form("d_2")
-    first, rest = lst[0], lst[1:]
-    s = tree_form("d_0")
-    eq = expand(simplify(first * product_to_sum(solve(TreeNode("f_mul", rest)))))
-    if eq.name == "f_add":
-        for child in eq.children:
-            s += product_to_sum(child)
-            s = simplify(s)
-    else:
-        s = eq
-    return s
+            out =((A + B).fx("sin") + (A - B).fx("sin")) / tree_form("d_2")
+            
+        return out * product(other)
+
+    rest = tree_form("d_1")
+    if len(lst) % 2 == 1:
+        rest = lst.pop(0)
+    out = []
+    for i in range(0, len(lst), 2):
+        out.append(product_to_sum(product(lst[i:i+2])))
+    expr = product(out)*rest*product(other)
+    
+    return dowhile(expr, cog)
+
 def trig_formula_init():
     var = ""
     formula_list = [(f"A*sin(B)+C*sin(B)", f"(A^2+C^2)^(1/2)*sin(B+arctan(C/A))"),\
@@ -159,56 +179,98 @@ def noneg_pow(eq):
     if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1])<0:
         return (eq.children[0]**(simplify(-eq.children[1])))**-1
     return TreeNode(eq.name, [noneg_pow(child) for child in eq.children])
-def _trig1(equation):
-    equation = product_to_sum(equation)
-    return TreeNode(equation.name, [_trig1(child) for child in equation.children])
-def trig1(eq):
-    return simplify(_trig1(noneg_pow(eq)))
     
-def trig4(eq, numer=True):
-    if eq.name == "f_sin":
-        if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
-            r = len(eq.children[0].children)%2
-            a, b = eq.children[0].children[:(len(eq.children[0].children)-r)/2], eq.children[0].children[(len(eq.children[0].children)-r)/2:]
-            return a.fx("sin")*b.fx("cos") + a.fx("cos")*b.fx("sin")
-        if eq.children[0].name == "f_arccos":
-            a = eq.children[0].children[0]
-            return (1-a**2)**(tree_form("d_2")**-1)
-        if eq.children[0].name == "f_arctan":
-            a = eq.children[0].children[0]
-            return a/(1+a**2)**(tree_form("d_2")**-1)
-    if eq.name == "f_pow" and numer:
-        if eq.children[0].name == "f_cos":
-            a = eq.children[0].children[0]
-            if frac(eq.children[1]) == 2:
-                return 1 - a.fx("sin")**2
-        if eq.children[0].name == "f_sin":
-            a = eq.children[0].children[0]
-            if frac(eq.children[1]) == 2:
-                return 1 - a.fx("cos")**2
-    if eq.name == "f_cos":
-        if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
-            r = len(eq.children[0].children)%2
-            a, b = eq.children[0].children[:(len(eq.children[0].children)-r)/2], eq.children[0].children[(len(eq.children[0].children)-r)/2:]
-            return a.fx("cos")*b.fx("cos") - a.fx("sin")*b.fx("sin")
-        if eq.children[0].name == "f_arcsin":
-            a = eq.children[0].children[0]
-            return (1-a**2)**(tree_form("d_2")**-1)
-        if eq.children[0].name == "f_arctan":
-            a = eq.children[0].children[0]
-            return tree_form("d_1")/(1+a**2)**(tree_form("d_2")**-1)
-    
-    return TreeNode(eq.name, [trig4(child, False) if not numer or (eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) < 0) else trig4(child, True) for child in eq.children])
+def trig1(eq):
+    eq = noneg_pow(eq)
+    return product_to_sum(eq)
+
+def trig4(eq):
+    done = False
+    def _trig4(eq, numer=True, chance="sin"):
+        nonlocal done
+        if eq.name == "f_sin":
+            if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
+                r = len(eq.children[0].children)%2
+                a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
+                       TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
+                if len(a.children)==1:
+                    a=a.children[0]
+                if len(b.children)==1:
+                    b=b.children[0]
+                return a.fx("sin")*b.fx("cos") + a.fx("cos")*b.fx("sin")
+            if eq.children[0].name == "f_arccos":
+                a = eq.children[0].children[0]
+                return (1-a**2)**(tree_form("d_2")**-1)
+            if eq.children[0].name == "f_arctan":
+                a = eq.children[0].children[0]
+                return a/(1+a**2)**(tree_form("d_2")**-1)
+        if eq.name == "f_pow" and numer:
+            if eq.children[0].name == "f_cos" and chance == "cos":
+                a = eq.children[0].children[0]
+                if frac(eq.children[1]) == 2:
+                    done = True
+                    return 1 - a.fx("sin")**2
+            if eq.children[0].name == "f_sin" and chance == "cos":
+                a = eq.children[0].children[0]
+                if frac(eq.children[1]) == 2:
+                    done = True
+                    return 1 - a.fx("cos")**2
+        if eq.name == "f_cos":
+            if eq.children[0].name == "f_add" and len(eq.children[0].children)>=2:
+                r = len(eq.children[0].children)%2
+                a, b = TreeNode("f_add", eq.children[0].children[:round((len(eq.children[0].children)-r)/2)]),\
+                       TreeNode("f_add", eq.children[0].children[round((len(eq.children[0].children)-r)/2):])
+                if len(a.children)==1:
+                    a=a.children[0]
+                if len(b.children)==1:
+                    b=b.children[0]
+                return a.fx("cos")*b.fx("cos") - a.fx("sin")*b.fx("sin")
+            if eq.children[0].name == "f_arcsin":
+                a = eq.children[0].children[0]
+                return (1-a**2)**(tree_form("d_2")**-1)
+            if eq.children[0].name == "f_arctan":
+                a = eq.children[0].children[0]
+                return tree_form("d_1")/(1+a**2)**(tree_form("d_2")**-1)
+        
+        return TreeNode(eq.name, [_trig4(child, False, chance) if eq.name != "f_add" and\
+                                  (not numer or (eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) < 0))\
+                                   else _trig4(child, True, chance) for child in eq.children])
+    eq= _trig4(eq)
+    if not done:
+        eq = _trig4(eq,"cos")
+    return eq
 def trig2(eq):
-    if eq.name == "f_add":
-        for item in itertools.combinations(range(len(eq.children)), 2):
-            if all(eq.children[item2].name == "f_sin" for item2 in item):
-                a, b = eq.children[item[0]].children[0], eq.children[item[1]].children[0]
-                rest = [item2 for index, item2 in enumerate(eq.children) if index not in item]
-                if len(rest)==0:
-                    rest = tree_form("d_0")
-                else:
-                    rest = summation(rest)
-                two = tree_form("d_2")
-                return rest + two*((a+b)/two).fx("sin")*((a-b)/two).fx("cos")
+    # Base case: if not an addition, recurse into children
+    if eq.name != "f_add":
+        return TreeNode(eq.name, [trig2(child) for child in eq.children])
+
+    # Try all pairs in the addition
+    for i, j in itertools.combinations(range(len(eq.children)), 2):
+        c1, c2 = eq.children[i], eq.children[j]
+
+        # Combine only sin/sin or cos/cos
+        if c1.name in ["f_sin", "f_cos"] and c2.name in ["f_sin", "f_cos"]:
+            A, B = c1.children[0], c2.children[0]
+            rest = [eq.children[k] for k in range(len(eq.children)) if k not in (i, j)]
+            rest_tree = summation(rest) if rest else tree_form("d_0")
+
+            two = tree_form("d_2")
+
+            # sinA + sinB
+            if c1.name == "f_sin" and c2.name == "f_sin":
+                combined = two * ((A + B) / two).fx("sin") * ((A - B) / two).fx("cos")
+
+            # cosA + cosB
+            elif c1.name == "f_cos" and c2.name == "f_cos":
+                combined = two * ((A + B) / two).fx("cos") * ((A - B) / two).fx("cos")
+
+            # sinA + cosB (leave unchanged)
+            else:
+                continue
+
+            new_expr = rest_tree + combined
+            # Re-run trig2 in case there are more sin/cos sums to simplify
+            return trig2(new_expr)
+
+    # If no sin/cos pairs found, just recurse on children
     return TreeNode(eq.name, [trig2(child) for child in eq.children])

mathai/univariate_inequality.py

@@ -3,13 +3,14 @@ import itertools
 from .base import *
 from .inverse import inverse
 from collections import Counter
-from .factor import factor2
-from .simplify import simplify, solve
+#from .factor import factor2
+from .simplify import simplify
 from .expand import expand
 from .fraction import fraction
 import copy
 from .diff import diff
 from .logic import logic0
+from .tool import poly, poly_simplify
 def intersection2(domain, lst):
     domain = copy.deepcopy(domain)
     if domain == [True]:
@@ -18,6 +19,7 @@ def intersection2(domain, lst):
         return []
     lst = [item for item in lst if item not in domain]
     out = []
+    
     for item2 in lst:
         for index in range(len(domain)):
             
@@ -167,7 +169,54 @@ class Range:
             return "U".join(out)
         else:
             return "U".join(out)+"-"+out2
-
+def prepare(eq):
+    if eq.name[2:] in "and not or".split(" "):
+        output = TreeNode(eq.name, [])
+        for child in eq.children:
+            out = prepare(child)
+            if out is None:
+                return None
+            output.children.append(out)
+        output = TreeNode(output.name, output.children)
+        return output
+    elif eq.name[2:] in "gt lt eq ge le".split(" "):
+        eq = simplify(eq)
+        out = prepare(eq.children[0])
+        if out is None:
+            return None
+        output = TreeNode(eq.name, [out, tree_form("d_0")])
+        
+        output = logic0(output)
+        return output
+    else:
+        eq = logic0(eq)
+        if eq.name in ["s_true", "s_false"]:
+            return eq
+        if len(vlist(eq)) != 1:
+            if "v_" not in str_form(eq):
+                return eq
+            return None
+        out = poly(eq, vlist(eq)[0])
+        if out is None or len(out) > 3:
+            
+            output = []
+            for item in factor_generation(eq):
+                if item.name == "f_pow" and item.children[1].name == "d_-1":
+                    out2 = poly(item.children[0], vlist(eq)[0])
+                    if out2 is not None and len(out2) <= 3:
+                        output.append(poly_simplify(item.children[0])**-1)
+                    else:
+                        return None
+                else:
+                    out2 = poly(item, vlist(eq)[0])
+                    if out2 is not None and len(out2) <= 3:
+                        output.append(poly_simplify(item))
+                    else:
+                        return None
+            return simplify(product(output))
+        else:
+            return poly_simplify(eq)
+    
 dic_table = {}
 def helper(eq, var="v_0"):
     global dic_table
@@ -180,7 +229,7 @@ def helper(eq, var="v_0"):
     if eq.children[0].name == "f_add":
         
         eq.children[0] = simplify(expand(eq.children[0]))
-        eq = simplify(factor2(eq))
+        #eq = simplify(factor2(eq))
     
         
     equ = False
@@ -198,10 +247,12 @@ def helper(eq, var="v_0"):
     more = []
     
     _, d = num_dem(eq.children[0])
-    d = factor2(d)
+    d = simplify(d)
+    
+    #d = factor2(d)
     
     for item in factor_generation(d):
-        
+         
         item = simplify(expand(item))
         if len(vlist(item)) != 0:
             v = vlist(item)[0]
@@ -210,7 +261,7 @@ def helper(eq, var="v_0"):
             out = inverse(item, vlist(item)[0])
             more.append(simplify(out))
     
-    eq.children[0] = factor2(eq.children[0])
+    #eq.children[0] = factor2(eq.children[0])
     
     for item in factor_generation(eq.children[0]):
         item = simplify(expand(item))
@@ -262,6 +313,7 @@ def helper(eq, var="v_0"):
     equal = list(set([simplify(item) for item in equal]))
     more = list(set([simplify(item) for item in more]))
     critical = [simplify(item) for item in critical]
+    
     critical = Counter(critical)
     
     critical = sorted(critical.items(), key=lambda x: compute(x[0]))
@@ -277,7 +329,6 @@ def helper(eq, var="v_0"):
         critical[i] = critical[i][0]
 
     
-    
     if eq.name == "f_eq":
         final = Range([False], equal, more)
         dic_table[eq2] = final
@@ -312,11 +363,6 @@ def wavycurvy(eq):
     return ra
 
 def absolute(equation):
-    if equation.name in ["f_and", "f_or", "f_not"]:
-        tmp = TreeNode(equation.name, [absolute(child) for child in equation.children])
-        if len(tmp.children)==1:
-            tmp =tmp.children[0]
-        return tmp
     def mul_abs(eq):
         if eq.name == "f_abs" and eq.children[0].name == "f_mul":
             return simplify(product([item.fx("abs") for item in factor_generation(eq.children[0])]))
@@ -326,10 +372,13 @@ def absolute(equation):
     def collectabs(eq):
         out = []
         if eq.name == "f_abs":
-            out.append(eq.children[0])
+            
+            out.append(eq)
             return out
         for child in eq.children:
             out += collectabs(child)
+            if out != []:
+                return out
         return out
     def abc(eq, arr):
         def trans(eq):
@@ -345,23 +394,16 @@ def absolute(equation):
                 return TreeNode(eq.name, [trans(child) for child in eq.children])
         return trans(eq)
     out = list(set(collectabs(equation)))
-    
-    out2 = []
-    for item in itertools.product([0,1,2], repeat=len(out)):
-        out3 = []
-        for i in range(len(item)):
-            out3.append(copy.deepcopy(TreeNode({0:"f_gt", 1:"f_lt", 2:"f_eq"}[item[i]], [out[i], tree_form("d_0")])))
-        out3 = TreeNode("f_and", out3+[abc(copy.deepcopy(equation), list(item))])
-        if len(out3.children) == 1:
-            out3 = out3.children[0]
-        out2.append(out3)
-    if len(out2) == 1:
-        return out2[0]
+    if out == []:
+        return logic0(equation)
     else:
-        equation = TreeNode("f_or", out2)
-    return equation
+        a = TreeNode("f_ge", [out[0].children[0], tree_form("d_0")]) & replace(equation, out[0], out[0].children[0])
+        b = TreeNode("f_lt", [out[0].children[0], tree_form("d_0")]) & replace(equation, out[0], -out[0].children[0])
+        return a | b
 def handle_sqrt(eq):
+    d= []
     def helper2(eq):
+        nonlocal d
         if eq.name in ["f_lt", "f_gt", "f_le", "f_ge","f_eq"]:
             out = []
             def helper(eq):
@@ -378,13 +420,19 @@ def handle_sqrt(eq):
                     eq2, sgn = inverse(simplify(eq.children[0]), str_form(item), True)
                     if sgn == False:
                         n = tree_form("d_-1")
+                d.append(TreeNode("f_ge", [eq2,tree_form("d_0")]))
+                #d.append(TreeNode("f_ge", [item.children[0],tree_form("d_0")]))
                 eq3 = simplify(expand(simplify(eq2**2)))
                 
                 return simplify(TreeNode(eq.name, [simplify(n*item.children[0]-eq3*n), tree_form("d_0")]))
+            
         return TreeNode(eq.name, [helper2(child) for child in eq.children])
-    return helper2(eq)
+    out = helper2(eq)
+    if len(d) == 0:
+        return out
+    return TreeNode("f_and", [helper2(eq)]+d)
 def domain(eq):
-    eq = solve(eq, True)
+    eq = simplify(eq)
     out = []
     def helper2(eq):
         nonlocal out

{mathai-0.4.0.dist-info → mathai-0.6.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.4.0
+Version: 0.6.9
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Author: educated indians are having a low iq and are good for nothing
@@ -16,6 +16,9 @@ Dynamic: requires-python
 Dynamic: summary
 
 # Math AI Documentation
+## Source
+Github repository of the code
+https://github.com/infinity390/mathai4
 
 ## Philosophy
 I think it is a big realization in computer science and programming to realize that computers can solve mathematics.  

mathai-0.6.9.dist-info/RECORD

@@ -0,0 +1,28 @@
+mathai/__init__.py,sha256=Mv0vNdV-FHKS6MzAsnHsE0eBtSkCUq0nc9tUgCWxbFo,1541
+mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
+mathai/base.py,sha256=mk5LTVcgOpd-Zh0VBGQmZQOBlH5G3XFQI_TzwXYaRss,15794
+mathai/bivariate_inequality.py,sha256=Da-A1kqVynR0tNOlEI7GSTf5T2vNkcF4etL9-EoyPJg,11415
+mathai/console.py,sha256=Sn58iwYE79MLEh67s8X3q6vZjw6g7f9XM1T8_dBBR2o,3048
+mathai/diff.py,sha256=RSTwlfeddvYXUDShCeRdcPjsmAS8Vf5OkYJAaUBPaiM,3060
+mathai/expand.py,sha256=NCe4LfM3-ndW78Zg8ZjlEVujb3-lG7_0H81ncRQizvw,2760
+mathai/factor.py,sha256=3wcmZOGUqMlLj4v2DA14ZLqEQ7khavOi7PjZJU6VX40,12494
+mathai/fraction.py,sha256=88xvRpDGfFi8tbe1QIyejdSP91HcErrN4VS2MxzbhrY,4392
+mathai/integrate.py,sha256=C_lqYgQN4UiriCb_LDkpwtKx7XJhp_K8T9skCkxWqas,17208
+mathai/inverse.py,sha256=ya7P8WjzfaAL3UXL7xqOh5GaIsXLDZ-F6lZFy3IEgaQ,2931
+mathai/limit.py,sha256=9F8i9UZh2xb-V8A5Sd1gdhDf9c2RFgpE1GdNn9MvbWI,5703
+mathai/linear.py,sha256=viGlPU8BPrjLWHlyNUvnfPHNH5d4ZBImiQMdyXaKGg0,5702
+mathai/logic.py,sha256=Ndz4Fd6aNCmzFlqoPyyIpSmV_BXmYHsurePjLyZJoNc,9809
+mathai/matrix.py,sha256=Owv7Xbn2emrSWqrvaqSHeWX5xPuQF5tkZICCuTbQAyQ,7288
+mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
+mathai/parser.py,sha256=nEAdSSJeapBOhvjbkXJFtCEBU8izajXZAITV8rbslic,7314
+mathai/parsetab.py,sha256=TL-4jvRM_Tx6ipwet8CFJc2DkjR4tGsbrGF_r4IC8xI,9651
+mathai/printeq.py,sha256=4UgLJo-vV_YlVw_3QUQY_jQMHrFnG-ZKAyVZsd7yD6o,1450
+mathai/simplify.py,sha256=VsUw89U3FqSpD3mMUGM0pr0dZ__MDQOBD8maaB7MDBY,19973
+mathai/structure.py,sha256=wrU7kqphSN7CqaVffyHHXD2-3t5My_Z_TtYFoUe_lTU,4099
+mathai/tool.py,sha256=ozcXTXLbKUnyPM9r9kz9M43YA2CBcWezcqLZfEs8rpc,6051
+mathai/trig.py,sha256=fnBbfiopcQzFg4ya1BoO5M0X_aCBnse2bjnKh1juw4I,11223
+mathai/univariate_inequality.py,sha256=LPFdWgC1y5zBwnsy1wwZxj-yP_SbqFDhCmTTzhuwoiY,16469
+mathai-0.6.9.dist-info/METADATA,sha256=6Q_imbUXwELM1E1VZap8NoO2fm9SFAhalIoi0nWsULg,7103
+mathai-0.6.9.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+mathai-0.6.9.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.6.9.dist-info/RECORD,,

{mathai-0.4.0.dist-info → mathai-0.6.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any