mathai 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

mathai/__init__.py

@@ -11,4 +11,5 @@ from .trig import trig0, trig1, trig2, trig3, trig4
 from .logic import logic0, logic1, logic2, logic3
 from .apart import apart
 from .console import console
+from .limit import limit
 from .base import *

mathai/base.py

@@ -145,6 +145,8 @@ def frac(eq):
         a = frac(eq.children[0])
         b = frac(eq.children[1])
         if isinstance(a, Fraction) and isinstance(b, Fraction) and b.denominator==1:
+            if a == 0 and b <= 0:
+                return None
             return a**b
         else:
             return None

mathai/expand.py

@@ -4,6 +4,8 @@ from .base import *
 from .simplify import solve, simplify
 
 def expand(eq):
+    if eq is None:
+        return None
     if eq.name == "f_mul" or eq.name == "f_pow":
         if eq.name == "f_pow":
             eq = TreeNode("f_pow", [eq]) 

mathai/limit.py

@@ -0,0 +1,126 @@
+from .structure import structure
+from .base import *
+from .parser import parse
+from .simplify import simplify, solve
+from .expand import expand
+from .diff import diff
+from .trig import trig0
+from .fraction import fraction
+from .printeq import printeq_str
+tab=0
+def substitute_val(eq, val, var="v_0"):
+    eq = replace(eq, tree_form(var), tree_form("d_"+str(val)))
+    return eq
+
+def subslimit(equation, var):
+    equation2 = trig0(replace(equation, var, tree_form("d_0")))
+    try:
+        tmp = simplify(equation2)
+        return simplify(expand(tmp))
+    except:
+        return None
+    
+def check(num, den, var):
+    n, d = None, None
+    
+    n, d = (dowhile(replace(e, var, tree_form("d_0")), lambda x: trig0(simplify(x))) for e in (num, den))
+    if n is None or d is None:
+        return False
+    if n == 0 and d == 0: return True
+    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,[]
+    for _ in range(steps):
+        num2, den2 = map(lambda e: simplify(diff(e, var.name)), (num, den))
+        out = check(num2, den2, var)
+        if out is True:
+            num, den = num2, den2
+            logs += [(0,"lim x->0 "+printeq_str(simplify(num/den)))]
+            continue
+        if out is False:
+            eq2 = simplify(fraction(simplify(num/den)))
+            return eq2,logs
+        return out,logs
+def lhospital2(eq, var):
+    eq=  simplify(eq)
+    if eq is None:
+        return None
+    if not contain(eq, var):
+        return eq,[]
+    num, dem = [simplify(item) for item in num_dem(eq)]
+    if num is None or dem is None:
+        return eq,[]
+    
+    return lhospital(num, dem, 10,var)
+ls = [parse("sin(A)"), parse("A^B-1"),parse("log(1+A)"), parse("cos(A)")]
+ls= [simplify(item) for item in ls]
+
+def approx(eq, var):
+    n, d= num_dem(eq)
+    n, d = solve(n), solve(d)
+    n, d = expand(n), expand(d)
+    out = []
+    for equation in [n, d]:
+        for item in factor_generation(equation):
+            tmp = structure(item, ls[0])
+            if tmp is not None and contain(tmp["v_-1"], var):
+                item2 = substitute_val(tmp["v_-1"], 0, var.name)
+                if tree_form("d_0") == expand(simplify(item2)):
+                    equation = equation/item
+                    equation = equation*tmp["v_-1"]
+                    break
+                elif tree_form("d_0") == expand(simplify(tree_form("s_pi") - item2)):
+                    equation = equation/item
+                    equation = equation*(tree_form("s_pi") - tmp["v_-1"])
+                    break
+            tmp = structure(item, ls[1])
+            if tmp is not None and contain(tmp["v_-1"], var) and not contain(tmp["v_-2"], var):
+                item2 = substitute_val(tmp["v_-1"], 0, var.name)
+                item2 = expand(solve(item2))
+                if tree_form("d_0") == item2:
+                    equation = equation/item
+                    equation = solve(equation*tmp["v_-1"]*tmp["v_-2"].fx("log"))
+                    break
+            tmp = structure(item, ls[2])
+            if tmp is not None and contain(tmp["v_-1"], var):
+                                
+                item2 = substitute_val(tmp["v_-1"], 0, var.name)
+                item2 = expand(solve(item2))
+                if tree_form("d_0") == item2:
+                    equation = equation/item
+                    equation = solve(equation*tmp["v_-1"])
+                    break
+            tmp = structure(item, ls[3])
+            if tmp is not None and contain(tmp["v_-1"], var):
+                item2 = substitute_val(item, 0, var.name)
+                
+                if tree_form("d_0") == expand(solve(item2)):
+                    
+                    equation = equation/item
+                    equation = equation*(tree_form("d_1") - tmp["v_-1"]**tree_form("d_2"))
+                    break
+                
+        equation = solve(equation)
+        out.append(equation)
+    return simplify(out[0]/out[1])
+def approx_limit(equation, var):
+    return dowhile(equation, lambda x: approx(x, var))
+
+def limit(equation, var=tree_form("v_0")):
+    logs = [(0,"lim x->0 "+printeq_str(simplify(equation)))]
+    eq2 = dowhile(replace(equation, var, tree_form("d_0")), lambda x: trig0(simplify(x)))
+    if eq2 is not None and not contain(equation, var):
+        return eq2,logs
+    equation, tmp = lhospital2(equation, var)
+    equation = simplify(expand(simplify(equation)))
+    if not contain(equation, var):
+        return equation,logs+tmp
+    '''
+    if equation.name == "f_add":
+        return simplify(summation([limit(child, var) for child in equation.children]))
+    '''
+    return equation,logs+tmp

mathai/simplify.py

@@ -157,6 +157,7 @@ def clear_div(eq):
     return solve(product(lst2))
 
 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")])
@@ -170,6 +171,11 @@ def simplify(eq):
             
             a, b = int(eq.children[0].name[2:]), int(eq.children[1].name[2:])
             a = a**abs(b)
+            if b == 0 and a == 0:
+                error= True
+                return eq
+            if b == 0:
+                b = 1
             b = int(b/abs(b))
             if b == 1:
                 eq = tree_form("d_"+str(a))
@@ -195,6 +201,9 @@ def simplify(eq):
             for i in range(len(eq.children)-1,-1,-1):
                 child= eq.children[i]
                 if child.name == "f_pow" and child.children[0].name[:2] == "d_" and child.children[1] == -1:
+                    if int(child.children[0].name[2:]) == 0:
+                        error = True
+                        return eq
                     n = n*Fraction(1,int(child.children[0].name[2:]))
                     eq.children.pop(i)
                 elif child.name[:2] == "d_":
@@ -209,7 +218,7 @@ def simplify(eq):
                 eq = eq.children[0]
         return TreeNode(eq.name, [helper3(child) for child in eq.children])
     def helper4(eq):
-        
+        nonlocal error
         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:
@@ -253,7 +262,10 @@ def simplify(eq):
         if eq.name == "f_pow" and eq.children[0] == tree_form("d_1"):
             eq = tree_form("d_1")
         if eq.name == "f_pow" and eq.children[0] == tree_form("d_0"):
-            eq = tree_form("d_0")
+            if frac(eq.children[1]) is not None and frac(eq.children[1]) <= 0:
+                error = True
+            else:
+                eq = tree_form("d_0")
         if eq.name == "f_pow" and eq.children[0].name == "f_pow" and eq.children[0].children[1] == tree_form("d_2")**-1 and eq.children[1] == tree_form("d_2"):
             eq = eq.children[0].children[0]
         if (eq.name == "f_sin" and eq.children[0].name == "f_arcsin") or (eq.name == "f_cos" and eq.children[0].name == "f_arccos") or (eq.name == "f_tan" and eq.children[0].name == "f_arctan"):
@@ -323,4 +335,6 @@ def simplify(eq):
         return eq
     eq = dowhile(eq, fx3)
     eq = dowhile(eq, helper8)
+    if error:
+        return None
     return solve(eq)

mathai/structure.py

@@ -55,7 +55,8 @@ def structure(equation, formula, formula_out=None, only_const=False):
             node.name = "f_mul"
         return TreeNode(node.name, [conversionrev(child) for child in node.children])
     equation = conversion(equation)
-    formula_out = conversion(formula_out)
+    if formula_out is not None:
+        formula_out = conversion(formula_out)
     for item in lst(formula):
         varlist = {}
         if helper(equation, item):

mathai/trig.py

@@ -32,6 +32,8 @@ for key in trig_cos_table.keys():
 for key in trig_sin_table.keys():
     trig_sin_table[key] = simplify(trig_sin_table[key])
 def trig0(eq):
+    if eq is None:
+        return None
     def isneg(eq):
         if eq.name[:2] != "d_":
             return False

mathai-0.2.2.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.2
+Name: mathai
+Version: 0.2.2
+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.0.dist-info → mathai-0.2.2.dist-info}/RECORD

@@ -1,22 +1,23 @@
-mathai/__init__.py,sha256=CIxRQncAAbHhI6YtrOI2HAiTyJX8reAoqnu7qfonVDc,504
+mathai/__init__.py,sha256=myFxwz93RBoOeNg9HhA0tsIqy1exyDrCzt1ewyHf9B0,530
 mathai/apart.py,sha256=P0B21wHUFitc5RGbNJlwSeOdseOMcav4I7teFNcZmFA,3130
-mathai/base.py,sha256=dnOCgCquNeSZY5tnd0aeXwOf1VxFrVMipdF4M92Bd-M,12223
+mathai/base.py,sha256=y6ARBJWtpXiLXOW1kAZczWq223r2j1dzTxj69YHHh7M,12287
 mathai/console.py,sha256=FsEMqDsgFeBSUiPCm9sfReZp56NSyoFVldqmVwvW4lg,3119
 mathai/diff.py,sha256=Dvc-tuiW8jLncybjGqHs2WTg2vpMEdRJqUoIdnDj4sk,2879
-mathai/expand.py,sha256=zI2QDjjPSP5dqzgTVhuAMnBlohApL1MRjPZe0v-ccTw,1753
+mathai/expand.py,sha256=RTSKEa2Jx537kSAnWcGskdNyhJeuHOOR4nWplVO-v9k,1794
 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=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=niSfqqzg44YGVuRRrQ9XG_K7Ak0Wj0WrRxQjkM0KBrw,13721
-mathai/structure.py,sha256=4lKbRNRAkLTZjvnWEeKLXg_tTeBPgc0VIz0evQq4-K8,4069
+mathai/simplify.py,sha256=Cg4ZmpcnE4_qS5e7-v6SS1UYoVhkjdWptLjrYl7jkB8,14196
+mathai/structure.py,sha256=Hgw2y43dwasa6G8z6OS2lmReh7JHwlChGn-FUdEaWY8,4106
 mathai/tool.py,sha256=87N5Ya7DmHdFOobTYDAjPHNWZuMzMIDjYN0ZtlHjxqE,1099
-mathai/trig.py,sha256=jWswDjThW-nR9RopseYqhy6NfdXtsgkcm7FInmH-oRo,6856
-mathai-0.2.0.dist-info/METADATA,sha256=H4abkBHhN8mPBIuAx4BdkVhEpxEkfJYjP0mstIIQRGc,741
-mathai-0.2.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mathai-0.2.0.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.2.0.dist-info/RECORD,,
+mathai/trig.py,sha256=ywu89MJfAB81JCzsVPBLpGGv8od0LhLn5cgDtLtYwmw,6897
+mathai-0.2.2.dist-info/METADATA,sha256=fOv2KC5cW4Z1tUTHrmZ_63QBsrQXbC40krT5IaIOCS4,7087
+mathai-0.2.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mathai-0.2.2.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.2.2.dist-info/RECORD,,

mathai-0.2.0.dist-info/METADATA

@@ -1,24 +0,0 @@
-Metadata-Version: 2.2
-Name: mathai
-Version: 0.2.0
-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