mathai 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

mathai/__init__.py

@@ -1,7 +1,7 @@
 from .expand import expand
 from .parser import parse
 from .printeq import printeq, printeq_log, printeq_str
-from .simplify import solve, simplify
+from .simplify import solve, simplify, solve2
 from .integrate import integrate, sqint, byparts
 from .diff import diff
 from .factor import factor, factor2
@@ -12,4 +12,5 @@ from .logic import logic0, logic1, logic2, logic3
 from .apart import apart
 from .console import console
 from .limit import limit
+from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
 from .base import *

mathai/base.py

@@ -193,7 +193,8 @@ def compute(eq):
 
     # Recursive case: compute child values
     values = [compute(child) for child in eq.children]
-
+    if None in values:
+        return None
     # Evaluate based on node type
     if eq.name == "f_add":
         return sum(values)

mathai/expand.py

@@ -52,5 +52,7 @@ def expand(eq):
                 add = add + mul
                 add = simplify(add)
             eq = add
+        eq = simplify(eq)
+        
     return TreeNode(eq.name, [expand(child) for child in eq.children])
 

mathai/inverse.py

@@ -1,10 +1,11 @@
 from .base import *
 from .simplify import solve
 from .expand import expand
-def inverse(rhs,term):
+def inverse(rhs,term, sign=None):
     term = tree_form(term)
     lhs = tree_form("d_0")
     count = 15
+    
     while not rhs==term:
         if rhs.name == "f_add":
             if all(term in factor_generation(child) for child in rhs.children):
@@ -20,6 +21,12 @@ def inverse(rhs,term):
             for i in range(len(rhs.children)-1,-1,-1):
                 if not contain(rhs.children[i], term):
                     lhs = lhs * rhs.children[i]**-1
+                    if sign is not None:
+                        if "v_" in str_form(rhs.children[i]):
+                            return None
+                        if compute(rhs.children[i]**-1) < 0:
+                            sign = not sign
+                    
                     rhs.children.pop(i)
         elif rhs.name == "f_pow" and contain(rhs.children[0], term):
             lhs = lhs ** (tree_form("d_1")/rhs.children[1])
@@ -53,5 +60,6 @@ def inverse(rhs,term):
         count -= 1
         if count == 0:
             return None
-    
-    return solve(lhs)
+    if sign is None:
+        return solve(lhs)
+    return solve(lhs), sign

mathai/limit.py

@@ -27,13 +27,13 @@ def check(num, den, var):
     if n is None or d is None:
         return False
     if n == 0 and d == 0: return True
-    if d != 0: return simplify(n/d)
+    if d != 0: return simplify(num/den)
     return False
 def lhospital(num, den, steps,var):
     logs = []
     out = check(num, den, var)
     if isinstance(out, TreeNode):
-        return out
+        return out,[]
     for _ in range(steps):
         num2, den2 = map(lambda e: simplify(diff(e, var.name)), (num, den))
         out = check(num2, den2, var)

mathai/simplify.py

@@ -144,25 +144,36 @@ def solve(eq, specialfx=False):
     eq = flatten_tree(eq)
     
     return dowhile(eq, _solve)
-
+def solve2(eq):
+    return solve(eq, True)    
 def clear_div(eq):
     lst = factor_generation(eq)
     if tree_form("d_0") in lst:
         return tree_form("d_0")
-    lst = [item for item in lst if not(item.name == "f_pow" and frac(item.children[1]) is not None and frac(item.children[1]) < 0)]
+    lst3 = [item for item in lst if "v_" not in str_form(item) and compute(item) < 0]
+    sign = True
+    if len(lst3) % 2 == 1:
+        sign = False
+    lst = [item for item in lst if not(item.name == "f_pow" and frac(item.children[1]) is not None and frac(item.children[1]) == -1)]
 
     lst2 = [item for item in lst if "v_" in str_form(item)]
     if lst2 == []:
-        return solve(product(lst))
-    return solve(product(lst2))
+        return solve(product(lst)),sign
+    return solve(product(lst2)),sign
 
 def simplify(eq):
     error = False
-    if eq.name == "f_eq":
-        if eq.children[1] != 0:
-            return TreeNode(eq.name, [clear_div(simplify(eq.children[0]-eq.children[1])), tree_form("d_0")])
-        else:
-            return TreeNode(eq.name, [clear_div(simplify(eq.children[0])), tree_form("d_0")])
+    eq = flatten_tree(eq)
+    if eq.name in ["f_and", "f_or", "f_not"]:
+        return TreeNode(eq.name, [simplify(child) for child in eq.children])
+        
+    if eq.name in ["f_lt", "f_gt", "f_le", "f_ge", "f_eq"]:
+        tmp, sign = clear_div(simplify(eq.children[0]-eq.children[1]))
+        name2 = eq.name
+        if not sign:
+            name2 = {"f_lt":"f_gt", "f_gt":"f_lt", "f_eq":"f_eq", "f_le":"f_ge", "f_ge":"f_le"}[name2]
+
+        return TreeNode(name2, [tmp, tree_form("d_0")])
 
     eq = solve(eq, True)
     def helper(eq):
@@ -219,6 +230,8 @@ def simplify(eq):
         return TreeNode(eq.name, [helper3(child) for child in eq.children])
     def helper4(eq):
         nonlocal error
+        if eq == tree_form("d_-1")**tree_form("d_-1"):
+            return tree_form("d_-1")
         def perfect_nth_root_value(x, n):
             """Return integer y if x is a perfect n-th power (y**n == x), else None."""
             if x < 0 and n % 2 == 0:
@@ -316,6 +329,8 @@ def simplify(eq):
             return eq.children[0].children[0]**eq.children[1]
         return TreeNode(eq.name, [helper5(child) for child in eq.children])
     def helper8(eq):
+        if eq.name == "f_pow" and eq.children[0].name == "f_abs" and frac(eq.children[1]) is not None and frac(eq.children[1]).numerator % 2==0:
+            return eq.children[0].children[0] ** eq.children[1]
         if eq.name == "f_abs" and eq.children[0].name == "f_abs":
             return eq.children[0]
         if eq.name == "f_cos" and eq.children[0].name == "f_abs":

mathai/univariate_inequality.py

@@ -0,0 +1,411 @@
+import itertools
+
+from .base import *
+from .inverse import inverse
+from collections import Counter
+from .factor import factor2
+from .simplify import simplify, solve
+from .expand import expand
+from .fraction import fraction
+import copy
+from .diff import diff
+from .logic import logic0
+def intersection2(domain, lst):
+    domain = copy.deepcopy(domain)
+    if domain == [True]:
+        return lst
+    elif domain == [True]:
+        return []
+    lst = [item for item in lst if item not in domain]
+    out = []
+    for item2 in lst:
+        for index in range(len(domain)):
+            
+            if isinstance(domain[index], bool) and domain[index]:
+                
+                if index == 0 and compute(item2) < compute(domain[index+1]):
+                    
+                    out.append(item2)
+                    break
+                elif index == len(domain)-1 and compute(domain[index-1]) < compute(item2):
+                    out.append(item2)
+                    break
+                elif index != 0 and index != len(domain)-1 and compute(domain[index-1]) < compute(item2) and compute(item2) < compute(domain[index+1]):
+                    
+                    out.append(item2)
+                    break
+                
+    return list(set(out))
+def flip_less_than(inter):
+    inter = copy.deepcopy(inter)
+    return [not item if isinstance(item, bool) else item for item in inter]
+def intersection(domain_1, domain_2):
+    domain_1, domain_2 = copy.deepcopy(domain_1), copy.deepcopy(domain_2)
+    if domain_1 == [True]:
+        return domain_2
+    if domain_2 == [True]:
+        return domain_1
+    if domain_1 == [False] or domain_2 == [False]:
+        return [False]
+    def simplify_ranges(ranges):
+        simplified_ranges = []
+        i = 0
+        while i < len(ranges):
+            if i + 2 < len(ranges) and ranges[i] is True and ranges[i + 2] is True:
+                simplified_ranges.append(True)
+                i += 3
+            elif i + 2 < len(ranges) and ranges[i] is False and ranges[i + 2] is False:
+                simplified_ranges.append(False)
+                i += 3
+            else:
+                simplified_ranges.append(ranges[i])
+                i += 1
+        return simplified_ranges
+    result = domain_1 + domain_2
+    result = [item for item in result if not isinstance(item, bool)]
+    result = list(set(result))
+    result = sorted(result, key=lambda x: compute(x))
+    i = len(result)
+    while i>=0:
+        result.insert(i, True)
+        i = i - 1
+    result[0] = domain_1[0] and domain_2[0]
+    result[-1] = domain_1[-1] and domain_2[-1]
+    def find_fraction_in_list(fraction_list, target_fraction):
+        for i in range(1, len(fraction_list)-1, 2):
+            if fraction_list[i] == target_fraction:
+                return i
+        return -1
+    for i in range(2, len(result)-1, 2):
+        if result[i+1] in domain_1:
+            result[i] = result[i] and domain_1[find_fraction_in_list(domain_1, result[i+1])-1]
+        if result[i+1] in domain_2:
+            result[i] = result[i] and domain_2[find_fraction_in_list(domain_2, result[i+1])-1]
+        if result[i-1] in domain_1:
+            result[i] = result[i] and domain_1[find_fraction_in_list(domain_1, result[i-1])+1]
+        if result[i-1] in domain_2:
+            result[i] = result[i] and domain_2[find_fraction_in_list(domain_2, result[i-1])+1]
+
+    result = simplify_ranges(result)
+    return result
+class Range:
+    def __init__(self, r=[True], p=[], z=[]):
+        self.r = r
+        self.p = p
+        self.z = z
+        self.do = True
+        
+    def unfix(self):
+        self.do = False
+        return self
+    def fix(self):
+        if not self.do:
+            return
+        def simplify_ranges(ranges):
+            simplified_ranges = []
+            i = 0
+            while i < len(ranges):
+                if i + 2 < len(ranges) and ranges[i] is True and ranges[i + 2] is True:
+                    simplified_ranges.append(True)
+                    i += 3
+                elif i + 2 < len(ranges) and ranges[i] is False and ranges[i + 2] is False:
+                    simplified_ranges.append(False)
+                    i += 3
+                else:
+                    simplified_ranges.append(ranges[i])
+                    i += 1
+            return simplified_ranges
+        
+        self.r = simplify_ranges(self.r)
+        
+        common = set(self.p) & set(self.z)
+        self.z = list(set(self.z) - common)
+        self.p = list(set(self.p) - common)
+        
+        self.p = list(set(self.p) - set(intersection2(self.r, self.p)))
+        self.z = list(set(intersection2(self.r, self.z)))
+        return self
+        
+    def __or__(self, other):
+        return (self.unfix().__invert__().unfix() & other.unfix().__invert__().unfix()).unfix().__invert__().fix()
+    def __invert__(self):
+        tmp =  Range(flip_less_than(self.r), self.z, list(set(self.p)-set(self.z)))
+
+        return tmp
+    def __and__(self, other):
+        a = intersection(self.r, other.r)
+        b = intersection2(self.r, other.p)
+        c = intersection2(other.r, self.p)
+        tmp = Range(a, list(set(b)|set(c)|(set(self.p)&set(other.p))), list(set(self.z)|set(other.z)))
+        return tmp
+    def __str__(self):
+
+        if self.r == [False] and self.p == [] and self.z == []:
+            return "{}"
+        out = []
+        out2 = ""
+        if self.r != [False]:
+            for i in range(0, len(self.r), 2):
+                string = ""
+                if self.r[i]:
+                    if i == 0:
+                        string += "(-inf,"
+                        if len(self.r)==1:
+                            string += "+inf)"
+                        else:
+                            string += str(self.r[i+1])+")"
+                    elif i == len(self.r)-1 and len(self.r)!=1:
+                        string += "("+str(self.r[i-1])+",+inf)"
+                    else:
+                        string += "("+str(self.r[i-1])+","+str(self.r[i+1])+")"
+                    out.append(string)
+        if self.p != []:
+            out.append("{"+",".join([str(item) for item in self.p])+"}")
+        if self.z != []:
+            out2 = "{"+",".join([str(item) for item in self.z])+"}"
+        if out2 == "":
+            return "U".join(out)
+        else:
+            return "U".join(out)+"-"+out2
+
+dic_table = {}
+def helper(eq, var="v_0"):
+    global dic_table
+    
+    eq2 = copy.deepcopy(eq)
+    
+    if eq2 in dic_table.keys():
+        return dic_table[eq2]
+    
+    if eq.children[0].name == "f_add":
+        
+        eq.children[0] = simplify(expand(eq.children[0]))
+        eq = simplify(factor2(eq))
+    
+        
+    equ = False
+    sign= True
+    if eq.name in ["f_gt", "f_ge"]:
+        sign = True
+    elif eq.name in ["f_lt", "f_le"]:
+        sign = False
+    if eq.name in ["f_ge", "f_le"]:
+        equ = True
+    if eq.name == "f_eq":
+        equ= True
+    critical = []
+    equal = []
+    more = []
+    
+    _, d = num_dem(eq.children[0])
+    d = factor2(d)
+    
+    for item in factor_generation(d):
+        
+        item = simplify(expand(item))
+        if len(vlist(item)) != 0:
+            v = vlist(item)[0]
+            if diff(diff(item, v), v) != tree_form("d_0"):
+                continue
+            out = inverse(item, vlist(item)[0])
+            more.append(simplify(out))
+    
+    eq.children[0] = factor2(eq.children[0])
+    
+    
+    for item in factor_generation(eq.children[0]):
+        item = simplify(expand(item))
+        
+        if len(vlist(item)) == 0:
+            if compute(item) <0:
+                sign = not sign
+            continue
+        v = vlist(item)[0]
+       
+        if item.name == "f_pow" and item.children[1].name== "d_-1":
+            
+            item = item.children[0]
+
+            tmp2 = diff(copy.deepcopy(item))
+            if "v_" in str_form(tmp2):
+                return None
+
+            
+            if diff(diff(item, v), v) != tree_form("d_0"):
+                
+                a = replace(diff(diff(item, v), v), tree_form(v), tree_form("d_0"))/tree_form("d_2")
+                if compute(a) < 0:
+                    sign = not sign
+                continue
+            
+            
+            if compute(tmp2)<0:
+                sign = not sign
+                item = simplify(item * tree_form("d_-1"))
+            out = inverse(item, vlist(item)[0])
+            critical.append(out)
+        else:
+            tmp2 = diff(copy.deepcopy(item))
+            if "v_" in str_form(tmp2):
+                return None
+            
+            if diff(diff(item, v), v) != tree_form("d_0"):
+                a = replace(diff(diff(item, v), v), tree_form(v), tree_form("d_0"))/tree_form("d_2")
+                if compute(a) < 0:
+                    sign = not sign
+                continue
+            
+            
+            if compute(tmp2)<0:
+                sign = not sign
+                item = simplify(item * tree_form("d_-1"))
+            out = inverse(item, vlist(item)[0])
+            critical.append(out)
+            if equ:
+                equal.append(str_form(out))
+    equal = list(set([simplify(tree_form(item)) for item in equal]))
+    more = list(set([simplify(tree_form(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]))
+
+    i = len(critical)
+    element = sign
+    while i>=0:
+        critical.insert(i, element)
+        if i>0 and critical[i-1][1] % 2 != 0:
+            element = not element
+        i = i - 1
+    for i in range(1, len(critical), 2):
+        critical[i] = critical[i][0]
+
+    
+    
+    if eq.name == "f_eq":
+        final = Range([False], equal, more)
+        dic_table[eq2] = final
+        return final
+  
+    final = Range(critical, equal, more)
+    dic_table[eq2] = final
+    return final
+def wavycurvy(eq):
+    if eq.name == "s_true":
+        return Range([True])
+    if eq.name == "s_false":
+        return Range([False])
+    if eq.name not in ["f_and", "f_or", "f_not"]:
+        
+        out = helper(eq)
+        if out is None:
+            return None
+        return out
+    lst= [wavycurvy(child) for child in eq.children]
+    if None in lst:
+        return None
+    ra = lst[0]
+    if eq.name == "f_and":
+        for child in lst[1:]:
+            ra = ra & child
+    elif eq.name == "f_or":
+        for child in lst[1:]:
+            ra = ra | child
+    elif eq.name == "f_not":
+        ra = ~ra
+    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])]))
+        return TreeNode(eq.name, [mul_abs(child) for child in eq.children])
+    equation = mul_abs(equation)
+            
+    def collectabs(eq):
+        out = []
+        if eq.name == "f_abs":
+            out.append(eq.children[0])
+            return out
+        for child in eq.children:
+            out += collectabs(child)
+        return out
+    def abc(eq, arr):
+        def trans(eq):
+            nonlocal arr
+            out = {}
+            if eq.name == "f_abs":
+                x = arr.pop(0)
+                if x == 0 or x==2:
+                    return eq.children[0]
+                else:
+                    return -eq.children[0]
+            else:  
+                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]
+    else:
+        equation = TreeNode("f_or", out2)
+    return equation
+def handle_sqrt(eq):
+    eq = domain(eq)
+    def helper2(eq):
+        if eq.name in ["f_lt", "f_gt", "f_le", "f_ge"]:
+            out = []
+            def helper(eq):
+                nonlocal out
+                if eq.name == "f_pow" and frac(eq.children[1]) == Fraction(1,2):
+                    out.append(simplify(eq))
+                x = [helper(child) for child in eq.children]
+            helper(eq)
+            for item in out:
+                
+                eq2, sgn = inverse(simplify(eq.children[0]), str_form(item), True)
+                n = tree_form("d_1")
+                if sgn == False:
+                    n = tree_form("d_-1")
+                eq3 = simplify(expand(simplify(eq2**2)))
+                eq2 = simplify(eq2)
+                if "v_" in str_form(eq3) and not (eq2.name == "f_pow" and frac(eq2.children[1]) == Fraction(1,2)):
+                    return simplify(TreeNode(eq.name, [simplify(n*item.children[0]-eq3*n), tree_form("d_0")])) & TreeNode("f_ge", [eq2, tree_form("d_0")])
+                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)
+def domain(eq):
+    eq = solve(eq, True)
+    out = []
+    def helper2(eq):
+        nonlocal out
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]).denominator == 2:
+            out.append(TreeNode("f_ge", [eq.children[0], tree_form("d_0")]))
+        if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) <0:
+            out.append(TreeNode("f_eq", [eq.children[0], tree_form("d_0")]).fx("not"))
+        x = [helper2(child) for child in eq.children]
+    helper2(eq)
+    out = list(set([simplify(item) for item in out]))
+    if out == []:
+        return eq
+    if len(out)==1:
+        out = out[0]
+    else:
+        out = TreeNode("f_and", list(out))
+    if eq.name in ["f_lt", "f_gt", "f_le", "f_ge", "f_eq"]:
+        return eq & out
+    return out

mathai-0.2.3.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.2
+Name: mathai
+Version: 0.2.3
+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
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: lark-parser
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Math AI Documentation
+
+## Philosophy
+I think it is a big realization in computer science and programming to realize that computers can solve mathematics.  
+This understanding should be made mainstream. It can help transform education, mathematical research, and computation of mathematical equations for work.
+
+## Societal Implications Of Such A Computer Program And The Author's Comment On Universities Of India
+I think mathematics is valued by society because of education. Schools and universities teach them.  
+So this kind of software, if made mainstream, could bring real change.
+
+### The Author's Comments On The Universities In His Country
+> Educated Indians are having a low IQ and are good for nothing.  
+> The Indian Institute of Technology (IITs) graduates are the leader of the fools.  
+> Every educated Indian is beneath me.  
+> Now learn how this Python library can solve the math questions of your exams.
+
+## The Summary Of How Computer "Solves" Math
+Math equations are a tree data structure (`TreeNode` class).  
+We can manipulate the math equations using various algorithms (functions provided by the `mathai` library).  
+We first parse the math equation strings to get the tree data structure (`parse` function in `mathai`).
+
+## The Library
+Import the library by doing:
+
+```python
+from mathai import *
+```
+
+### str_form
+It is the string representation of a `TreeNode` math equation.
+
+#### Example
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+Is represented internally as:
+
+```text
+f_add
+ f_pow
+  f_cos
+   v_0
+  d_2
+ f_pow
+  f_sin
+   v_0
+  d_2
+```
+
+#### Leaf Nodes
+
+**Variables** (start with a `v_` prefix):
+
+- `v_0` → x
+- `v_1` → y
+- `v_2` → z
+- `v_3` → a
+
+**Numbers** (start with `d_` prefix; only integers):
+
+- `d_-1` → -1
+- `d_0` → 0
+- `d_1` → 1
+- `d_2` → 2
+
+#### Branch Nodes
+- `f_add` → addition
+- `f_mul` → multiplication
+- `f_pow` → power
+
+### parse
+Takes a math equation string and outputs a `TreeNode` object.
+
+```python
+from mathai import *
+
+equation = parse("sin(x)^2+cos(x)^2")
+print(equation)
+```
+
+#### Output
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+### printeq, printeq_str, printeq_log
+Prints math equations in a more readable form than usual `print`.
+
+```python
+from mathai import *
+
+equation = simplify(parse("(x+1)/x"))
+print(equation)
+printeq(equation)
+```
+
+#### Output
+```text
+(1+x)*(x^-1)
+(1+x)/x
+```
+
+### solve, simplify
+`simplify` performs what `solve` does and more.  
+It simplifies and cleans up a given math equation.
+
+```python
+from mathai import *
+
+equation = simplify(parse("(x+x+x+x-1-1-1-1)*(4*x-4)*sin(sin(x+x+x)*sin(3*x))"))
+printeq(equation)
+```
+
+#### Output
+```text
+((-4+(4*x))^2)*sin((sin((3*x))^2))
+```
+
+### Incomplete Documentation, Will be updated and completed later on
+
+### Example Demonstration [limits questions can also be solved other than this these, try limit()]
+![pip-install-mathai-mathematics-solving-ai-system-in-python-v0-xcg3c22k51sf1](https://github.com/user-attachments/assets/799f576f-27d0-4d7c-86e9-ad55ff221bcc)
+```python
+import sys, os, time
+from mathai import *
+
+sys.setrecursionlimit(10000)
+
+def integration_byparts(item): return simplify(fraction(simplify(byparts(simplify(parse(item)))[0])))
+def integration_apart(item): return simplify(fraction(integrate(apart(factor2(simplify(parse(item)))))[0]))
+def integration_direct(item): return simplify(fraction(simplify(integrate(simplify(parse(item)))[0])))
+def integration_trig(item): return simplify(trig0(integrate(trig1(simplify(parse(item))))[0]))
+def algebra(item): return logic0(simplify(expand(simplify(parse(item)))))
+def trig_basic(item): return logic0(simplify(expand(trig3(simplify(parse(item))))))
+def trig_advanced(item): return logic0(simplify(trig0(trig1(trig4(simplify(fraction(trig0(simplify(parse(item))))))))))
+
+all_tasks = [
+    *[(item, trig_advanced) for item in [
+        "cos(x)/(1+sin(x)) + (1+sin(x))/cos(x) = 2*sec(x)",
+        "(1+sec(x))/sec(x) = sin(x)^2/(1-cos(x))"]],
+    *[(item, integration_byparts) for item in ["sin(x)*x","x*sin(3*x)","x*log(abs(x))","arctan(x)"]],
+    *[(item, integration_apart) for item in ["x/((x+1)*(x+2))","1/(x^2-9)"]],
+    *[(item, integration_direct) for item in [
+        "x*sqrt(x+2)","sin(cos(x))*sin(x)","2*x/(1+x^2)","sqrt(a*x+b)","cos(sqrt(x))/sqrt(x)","e^(arctan(x))/(1+x^2)","sqrt(sin(2*x))*cos(2*x"]], 
+    *[(item, integration_trig) for item in ["sin(2*x+5)^2","sin(x)^4","cos(2*x)^4"]],
+    *[(item, algebra) for item in ["(x+1)^2 = x^2+2*x+1","(x+1)*(x-1) = x^2-1"]],
+    *[(item, trig_basic) for item in ["2*sin(x)*cos(x)=sin(2*x)"]],
+]
+
+def run_task(task):
+    item, func = task
+    try: result = func(item)
+    except Exception as e: result = str(e)
+    return item, result
+
+if __name__=="__main__":
+    print(f"Solving {len(all_tasks)} math questions...\n")
+    start_time = time.time()
+    for task in all_tasks:
+        item, result = run_task(task)
+        print(f"{item}  =>  {result}\n")
+    print(f"All tasks completed in {time.time()-start_time:.2f} seconds")
+```
+### Output
+
+```
+Running 21 tasks asynchronously on 8 cores...
+
+x*log(abs(x))  =>  ((-2*(x^2))+(4*log(abs(x))*(x^2)))*(8^-1)
+
+arctan(x)  =>  (log((abs((1+(x^2)))^-1))+(2*arctan(x)*x))*(2^-1)
+
+sin(cos(x))*sin(x)  =>  cos(cos(x))
+
+1/(x^2-9)  =>  (log(abs((-3+x)))+log((abs((3+x))^-1)))*(6^-1)
+
+x/((x+1)*(x+2))  =>  log((abs((1+x))^-1))+log(((2+x)^2))
+
+x*sin(3*x)  =>  ((-9*cos((3*x))*x)+(3*sin((3*x))))*(27^-1)
+
+(1+sec(x))/sec(x) = sin(x)^2/(1-cos(x))  =>  true
+
+e^(arctan(x))/(1+x^2)  =>  e^arctan(x)
+
+cos(sqrt(x))/sqrt(x)  =>  2*sin((x^(2^-1)))
+
+sqrt(a*x+b)  =>  2*(3^-1)*(((x*a)+b)^(3*(2^-1)))*(a^-1)
+
+sin(x)*x  =>  (-1*cos(x)*x)+sin(x)
+
+(x+1)^2 = x^2+2*x+1  =>  true
+
+(x+1)*(x-1) = x^2-1  =>  true
+
+cos(x)/(1+sin(x)) + (1+sin(x))/cos(x) = 2*sec(x)  =>  true
+
+2*sin(x)*cos(x)=sin(2*x)  =>  true
+
+sqrt(sin(2*x))*cos(2*x)  =>  (3^-1)*(sin((2*x))^(3*(2^-1)))
+
+2*x/(1+x^2)  =>  log(abs((1+(x^2))))
+
+sin(2*x+5)^2  =>  ((-1*(4^-1)*sin((10+(4*x))))+x)*(2^-1)
+
+cos(2*x)^4  =>  ((4^-1)*x)+((64^-1)*sin((8*x)))+((8^-1)*sin((4*x)))+((8^-1)*x)
+
+x*sqrt(x+2)  =>  ((-1*(4^-1)*((2+x)^(2+(2^-1))))+(-2*((2+x)^(2+(2^-1))))+(5*((2+x)^(1+(2^-1)))*x)+((2^-1)*((2+x)^(1+(2^-1)))*x)+((8^-1)*((2+x)^(1+(2^-1)))*x))*((1+(2^-1))^-3)*((2+(2^-1))^-1)
+
+sin(x)^4  =>  (-1*(4^-1)*sin((2*x)))+((32^-1)*sin((4*x)))+((4^-1)*x)+((8^-1)*x)
+
+All tasks completed in 129.78 seconds
+```
+

{mathai-0.2.1.dist-info → mathai-0.2.3.dist-info}/RECORD

@@ -1,23 +1,24 @@
-mathai/__init__.py,sha256=myFxwz93RBoOeNg9HhA0tsIqy1exyDrCzt1ewyHf9B0,530
+mathai/__init__.py,sha256=1e8IUnfQv45U_EIp4GS_ugwVQlqQPWoWn3td5pTF5Lk,615
 mathai/apart.py,sha256=P0B21wHUFitc5RGbNJlwSeOdseOMcav4I7teFNcZmFA,3130
-mathai/base.py,sha256=y6ARBJWtpXiLXOW1kAZczWq223r2j1dzTxj69YHHh7M,12287
+mathai/base.py,sha256=8grzVyhvSrlpBRe-0ThkVGJtl9uokwzeOVHT1GcgznQ,12330
 mathai/console.py,sha256=FsEMqDsgFeBSUiPCm9sfReZp56NSyoFVldqmVwvW4lg,3119
 mathai/diff.py,sha256=Dvc-tuiW8jLncybjGqHs2WTg2vpMEdRJqUoIdnDj4sk,2879
-mathai/expand.py,sha256=RTSKEa2Jx537kSAnWcGskdNyhJeuHOOR4nWplVO-v9k,1794
+mathai/expand.py,sha256=IqkxHS8lqbk0PZqz2y_IbRMSP0GExV6fneYwVEWQ9XM,1831
 mathai/factor.py,sha256=1-Bxl3MX6P1mYM-CX0hRskCrTZWHFdaUL-V1OqX48hY,5316
 mathai/fraction.py,sha256=KGldpi8mndp5cvp6qbN7ZdMZyVmK6popa3AwkWmHXl4,2573
 mathai/integrate.py,sha256=I_9hIi3m9eoYjYwBbp_Bu1VXVRiXbUqYcJfL3cpLBPk,12652
-mathai/inverse.py,sha256=jd3YMqFgeHBUh9JoZa-1Wqh5lXZNB_UcrSD1paZYn-Q,2578
-mathai/limit.py,sha256=UOecxbq1ySSZce3dT0wfGfhyPynG5CmdcAbrzkTPXCo,4855
+mathai/inverse.py,sha256=QCvDrzKquWsZv-BDAzZd9HnU0c3gZvcc44UztHVO5LQ,2919
+mathai/limit.py,sha256=hmh7hgZHMHqkfLui5KSNtGfkUBzNTBvVmDkFNiXupXo,4862
 mathai/linear.py,sha256=eVnDbJYC1TWwg4J7ovBKsaHYlSoDmXk5jQpsqwtVPyI,5481
 mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
 mathai/parser.py,sha256=ENtMMm7Q_5QZL6cjbwsXGVJv-H53ueCPGEosJy4LcjY,6809
 mathai/printeq.py,sha256=JTB0_RBcgt1yFviqlHtXGXuSXcpKrxzSxj5WHkOHon4,1318
-mathai/simplify.py,sha256=Cg4ZmpcnE4_qS5e7-v6SS1UYoVhkjdWptLjrYl7jkB8,14196
+mathai/simplify.py,sha256=Fs4Ggu4pSpZw5GrEFmXs8YMLWJ8NeYhJZSdnwG1H5U4,14939
 mathai/structure.py,sha256=Hgw2y43dwasa6G8z6OS2lmReh7JHwlChGn-FUdEaWY8,4106
 mathai/tool.py,sha256=87N5Ya7DmHdFOobTYDAjPHNWZuMzMIDjYN0ZtlHjxqE,1099
 mathai/trig.py,sha256=ywu89MJfAB81JCzsVPBLpGGv8od0LhLn5cgDtLtYwmw,6897
-mathai-0.2.1.dist-info/METADATA,sha256=nI6xnVdiD2HHECrof4FWV0t2dV61Tw53pltur-RJIq0,741
-mathai-0.2.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mathai-0.2.1.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.2.1.dist-info/RECORD,,
+mathai/univariate_inequality.py,sha256=osifXsXDAbyv6Rr6AaiBONBPu4kzaaNxTjuMKTphUEQ,14739
+mathai-0.2.3.dist-info/METADATA,sha256=6jMZWRA0amOclCUg4xA0HGDNlpijkN_G6JkDDT3FEno,7087
+mathai-0.2.3.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mathai-0.2.3.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.2.3.dist-info/RECORD,,

mathai-0.2.1.dist-info/METADATA

@@ -1,24 +0,0 @@
-Metadata-Version: 2.2
-Name: mathai
-Version: 0.2.1
-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
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: lark-parser
-Dynamic: author
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-educated indians are having a low iq and are good for nothing
-
-the indian institute of technology graduates are the leader of the fools
-
-every educated indian is beneath me
-
-now learn how this python library can solve the math questions of your exams