mathai 0.4.8__py3-none-any.whl → 0.7.2__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

@@ -1,6 +1,6 @@
 from .diff import diff
 from .expand import expand
-from .simplify import simplify, solve
+from .simplify import simplify
 from .base import *
 import math
 
@@ -159,5 +159,5 @@ def poly(eq, to_compute, m=10):
     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
@@ -99,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))"),\
@@ -162,11 +179,11 @@ 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)))
+    eq = noneg_pow(eq)
+    return product_to_sum(eq)
+
 def trig4(eq):
     done = False
     def _trig4(eq, numer=True, chance="sin"):

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.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.7.2.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=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=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
+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=sIusSmZN0Y6k4TovI5L6Hepls9i7FPRjA3CZIU4X4_w,7276
+mathai/ode.py,sha256=zxxTXAOpt7oSsfpgI4vHsCWKXevmM96ZOBZWWs-vj8Y,4801
+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
+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.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.4.8.dist-info → mathai-0.7.2.dist-info}/WHEEL

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