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

mathai/base.py

@@ -370,21 +370,23 @@ def product(lst):
     for item in lst[1:]:
         s *= item
     return s
-def flatten_tree(node, add=[]):
+def flatten_tree(node):
+    if node is None:
+        return None
     if not node.children:
         return node
     ad = []
     if node.name in ["f_add", "f_mul", "f_and", "f_or", "f_wmul"]:
         merged_children = []
         for child in node.children:
-            flattened_child = flatten_tree(child, add)
+            flattened_child = flatten_tree(child)
             if flattened_child.name == node.name:
                 merged_children.extend(flattened_child.children)
             else:
                 merged_children.append(flattened_child)
         return TreeNode(node.name, merged_children)
     else:
-        node.children = [flatten_tree(child, add) for child in node.children]
+        node.children = [flatten_tree(child) for child in node.children]
         return node
 def dowhile(eq, fx):
     if eq is None:

mathai/expand.py

@@ -72,6 +72,84 @@ def expand_once(node):
 
     return node, False
 
+def _expand2(equation):
+    """Iterative version of _expand without recursion."""
+    # Stack: (node, child_index, partially_processed_children)
+    stack = [(equation, 0, [])]
+
+    while stack:
+        node, child_index, processed_children = stack.pop()
+
+        # If all children are processed
+        if child_index >= len(node.children):
+            # Replace children with processed versions
+            node.children = processed_children
+
+            # === Handle f_pow ===
+            if node.name == "f_pow":
+                n = frac(node.children[1])
+                if n is not None and n.denominator == 1 and n.numerator > 1:
+                    # Convert power to repeated multiplication
+                    power_children = [node.children[0] for _ in range(n.numerator)]
+                    new_node = TreeNode("f_mul", power_children)
+                    # Flatten tree
+                    node = flatten_tree(new_node)
+                    # Push it back for further processing
+                    stack.append((node, 0, []))
+                    continue
+
+            # === Handle f_mul ===
+            elif node.name == "f_mul":
+                # Separate lone children and bracket children
+                lone_children = tree_form("d_1")
+                bracket_children = []
+
+                # Iterate in reverse (like original)
+                for child in reversed(node.children):
+                    if child.name == "f_add":
+                        bracket_children.append(child)
+                    elif child.name == "f_pow" and child.children[0].name == "f_add":
+                        n = frac(child.children[1])
+                        if n is not None and n.denominator == 1 and n.numerator > 1:
+                            for _ in range(n.numerator):
+                                bracket_children.append(child.children[0])
+                        else:
+                            lone_children = lone_children * child
+                    else:
+                        lone_children = lone_children * child
+
+                lone_children = simplify(lone_children)
+
+                # Distribute bracket children over lone children iteratively
+                while bracket_children:
+                    tmp = tree_form("d_0")
+                    bracket = bracket_children.pop(0)
+                    for bc in bracket.children:
+                        if lone_children.name == "f_add":
+                            for lc in lone_children.children:
+                                tmp = tmp + bc * lc
+                        else:
+                            tmp = tmp + bc * lone_children
+                    # Simplify after each distribution
+                    lone_children = flatten_tree(simplify(tmp))
+
+                node = lone_children
+
+            # === Return node to parent ===
+            if stack:
+                parent, idx, parent_children = stack.pop()
+                parent_children.append(node)
+                stack.append((parent, idx + 1, parent_children))
+            else:
+                # Root node fully expanded
+                return node
+
+        else:
+            # Push current node back for next child
+            stack.append((node, child_index, processed_children))
+            # Push the child to process next
+            child = flatten_tree(node.children[child_index])
+            stack.append((child, 0, []))
 
 # =====================================================
 # Phase 3: Global fixed-point driver
@@ -79,6 +157,8 @@ def expand_once(node):
 
 def expand(eq):
     orig = TreeNode.matmul
+    if TreeNode.matmul is None:
+        return _expand2(eq)
     eq = simplify(eq)
     if TreeNode.matmul is not None:
         TreeNode.matmul = True

mathai/matrix.py

@@ -215,7 +215,7 @@ def fold_wmul(root):
     return newnode[root]
 
 def flat(eq):
-    return flatten_tree(eq, ["f_wmul"])
+    return flatten_tree(eq)
 def use(eq):
     return TreeNode(eq.name, [use(child) for child in eq.children])
 def _matrix_solve(eq):

mathai/parser.py

@@ -154,7 +154,7 @@ def parse(equation, funclist=None):
         return tree_node
     
     tree_node = rfx(tree_node)
-    tree_node = flatten_tree(tree_node, ["f_wmul"])
+    tree_node = flatten_tree(tree_node)
     if TreeNode.matmul == True:
         TreeNode.matmul = False
         tree_node = use(tree_form(str_form(tree_node).replace("f_w","f_")))

mathai-0.7.2.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: mathai
+Version: 0.7.2
+Summary: Mathematics solving Ai tailored to NCERT
+Home-page: https://github.com/infinity390/mathai4
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: lark-parser
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+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.  
+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 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)
+```
+
+### solve, simplify
+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
+
+### Demonstrations
+
+#### Example Demonstration 1 (absolute value inequalities)
+```python
+from mathai import *
+question_list_from_lecture = [
+    "2*x/(2*x^2 + 5*x + 2) > 1/(x + 1)",
+    "(x + 2)*(x + 3)/((x - 2)*(x - 3)) <= 1",
+    "(5*x - 1) < (x + 1)^2 & (x + 1)^2 < 7*x - 3",
+    "(2*x - 1)/(2*x^3 + 3*x^2 + x) > 0",
+    "abs(x + 5)*x + 2*abs(x + 7) - 2 = 0",
+    "x*abs(x) - 5*abs(x + 2) + 6 = 0",
+    "x^2 - abs(x + 2) + x > 0",
+    "abs(abs(x - 2) - 3) <= 2",
+    "abs(3*x - 5) + abs(8 - x) = abs(3 + 2*x)",
+    "abs(x^2 + 5*x + 9) < abs(x^2 + 2*x + 2) + abs(3*x + 7)"
+]
+
+for item in question_list_from_lecture:
+  eq = simplify(parse(item))
+  eq = dowhile(eq, absolute)
+  eq = simplify(factor1(fraction(eq)))
+  eq = prepare(eq)
+  eq = factor2(eq)
+  c = wavycurvy(eq & domain(eq)).fix()
+  print(c)
+```
+#### Output
+
+```
+(-2,-1)U(-(2/3),-(1/2))
+(-inf,0)U(2,3)U{0}
+(2,4)
+(-inf,-1)U(-(1/2),0)U(1/2,+inf)
+{-4,-3,-(3/2)-(sqrt(57)/2)}
+{-1,(5/2)-(sqrt(89)/2),(5/2)+(sqrt(41)/2)}
+(-inf,-sqrt(2))U((2*sqrt(2))/2,+inf)
+(-3,1)U(3,7)U{1,-3,7,3}
+(5/3,8)U{5/3,8}
+(-inf,-(7/3))
+```
+
+#### Example Demonstration 2 (trigonometry)
+```python
+from mathai import *
+def nested_func(eq_node):
+    eq_node = fraction(eq_node)
+    eq_node = simplify(eq_node)
+    eq_node = trig1(eq_node)
+    eq_node = trig0(eq_node)
+    return eq_node
+for item in ["(cosec(x)-cot(x))^2=(1-cos(x))/(1+cos(x))", "cos(x)/(1+sin(x)) + (1+sin(x))/cos(x) = 2*sec(x)",\
+             "tan(x)/(1-cot(x)) + cot(x)/(1-tan(x)) = 1 + sec(x)*cosec(x)", "(1+sec(x))/sec(x) = sin(x)^2/(1-cos(x))",\
+             "(cos(x)-sin(x)+1)/(cos(x)+sin(x)-1) = cosec(x)+cot(x)"]:
+  eq = logic0(dowhile(parse(item), nested_func))
+  print(eq)
+```
+#### Output
+
+```
+true
+true
+true
+true
+true
+```
+
+#### Example Demonstration 3 (integration)
+```python
+from mathai import *
+
+eq = simplify(parse("integrate(2*x/(x^2+1),x)"))
+eq = integrate_const(eq)
+eq = integrate_fraction(eq)
+print(simplify(fraction(simplify(eq))))
+
+eq = simplify(parse("integrate(sin(cos(x))*sin(x),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(eq))
+
+eq = simplify(parse("integrate(x*sqrt(x+2),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = expand(eq)
+eq = integrate_const(eq)
+eq = integrate_summation(eq)
+eq = simplify(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(fraction(simplify(eq))))
+
+eq = simplify(parse("integrate(x/(e^(x^2)),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = simplify(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(eq))
+
+eq = fraction(trig0(trig1(simplify(parse("integrate(sin(x)^4,x)")))))
+eq = integrate_const(eq)
+eq = integrate_summation(eq)
+eq = integrate_formula(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+print(factor0(simplify(fraction(simplify(eq)))))
+```
+#### Output
+
+```
+log(abs((1+(x^2))))
+cos(cos(x))
+((6*((2+x)^(5/2)))-(20*((2+x)^(3/2))))/15
+-((e^-(x^2))/2)
+-(((8*sin((2*x)))-(12*x)-sin((4*x)))/32)
+```
+
+#### Example Demonstration 4 (derivation of hydrogen atom's ground state energy in electron volts using the variational principle in quantum physics)
+```python
+from mathai import *;
+def auto_integration(eq):
+    for _ in range(3):
+        eq=dowhile(integrate_subs(eq),lambda x:integrate_summation(integrate_const(integrate_formula(simplify(expand(x))))));
+        out=integrate_clean(copy.deepcopy(eq));
+        if "f_integrate" not in str_form(out):return dowhile(out,lambda x:simplify(fraction(x)));
+        eq=integrate_byparts(eq);
+    return eq;
+z,k,m,e1,hbar=map(lambda s:simplify(parse(s)),["1","8987551787","9109383701*10^(-40)","1602176634*10^(-28)","1054571817*10^(-43)"]);
+pi,euler,r=tree_form("s_pi"),tree_form("s_e"),parse("r");a0=hbar**2/(k*e1**2*m);psi=((z**3/(pi*a0**3)).fx("sqrt"))*euler**(-(z/a0)*r);
+laplace_psi=diff(r**2*diff(psi,r.name),r.name)/r**2;V=-(k*z*e1**2)/r;Hpsi=-hbar**2/(2*m)*laplace_psi+V*psi;
+norm=lambda f:simplify(
+    limit3(limit2(expand(TreeNode("f_limitpinf",[auto_integration(TreeNode("f_integrate",[f*parse("4")*pi*r**2,r])),r]))))
+    -limit1(TreeNode("f_limit",[auto_integration(TreeNode("f_integrate",[f*parse("4")*pi*r**2,r])),r]))
+);
+print(compute(norm(psi*Hpsi)/(norm(psi**2)*e1)));
+```
+#### Output
+
+```
+-13.605693122882867
+```
+
+#### Example Demonstration 5 (boolean algebra)
+```python
+from mathai import *
+print(logic_n(simplify(parse("~(p<->q)<->(~p<->q)"))))
+print(logic_n(simplify(parse("(p->q)<->(~q->~p)"))))
+```
+#### Output
+
+```
+true
+true
+```
+
+#### Example Demonstration 6 (limits)
+```python
+from mathai import *
+limits = ["(e^(tan(x)) - 1 - tan(x)) / x^2", "sin(x)/x", "(1-cos(x))/x^2", "(sin(x)-x)/sin(x)^3"]
+for q in limits:
+    q = fraction(simplify(TreeNode("f_limit",[parse(q),parse("x")])))
+    q = limit1(q)
+    print(q)
+```
+#### Output
+
+```
+1/2
+1
+1/2
+-(1/6)
+```

{mathai-0.6.9.dist-info → mathai-0.7.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
 mathai/__init__.py,sha256=Mv0vNdV-FHKS6MzAsnHsE0eBtSkCUq0nc9tUgCWxbFo,1541
 mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=mk5LTVcgOpd-Zh0VBGQmZQOBlH5G3XFQI_TzwXYaRss,15794
+mathai/base.py,sha256=hRiJWS94asWl-t11eGrVCEhZqIub0T-8S_Eqmlun6mI,15819
 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/expand.py,sha256=r2Ha6graDLgLOlx3ox4egUvJD5L_-4_n-FQs2wyWVKg,6284
 mathai/factor.py,sha256=3wcmZOGUqMlLj4v2DA14ZLqEQ7khavOi7PjZJU6VX40,12494
 mathai/fraction.py,sha256=88xvRpDGfFi8tbe1QIyejdSP91HcErrN4VS2MxzbhrY,4392
 mathai/integrate.py,sha256=C_lqYgQN4UiriCb_LDkpwtKx7XJhp_K8T9skCkxWqas,17208
@@ -12,9 +12,9 @@ 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/matrix.py,sha256=sIusSmZN0Y6k4TovI5L6Hepls9i7FPRjA3CZIU4X4_w,7276
 mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
-mathai/parser.py,sha256=nEAdSSJeapBOhvjbkXJFtCEBU8izajXZAITV8rbslic,7314
+mathai/parser.py,sha256=3cBl7DhqL275gqXszET5zC85O9v3XKxRPc2EaOigAns,7302
 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
@@ -22,7 +22,7 @@ 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.7.2.dist-info/METADATA,sha256=e4tsi5hAzJaj4cqRDXewQl3SueJlmBt8ePY3Jvxbwj4,7742
+mathai-0.7.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mathai-0.7.2.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.7.2.dist-info/RECORD,,

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

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

mathai-0.6.9.dist-info/METADATA

@@ -1,234 +0,0 @@
-Metadata-Version: 2.4
-Name: mathai
-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
-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
-## 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.  
-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
-```
-