mathai 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

mathai/__init__.py

@@ -35,7 +35,8 @@ from .inverse import inverse
 
 from .trig import trig0, trig1, trig2, trig3, trig4
 
-from .logic import logic0, logic1, logic2, logic3, logic_n
+from .logic import logic0, logic1, logic2, logic3, logic_n, set_sub
+from .logic import auto_apply as logic_x
 
 from .apart import apart, apart2
 

mathai/apart.py

@@ -107,13 +107,14 @@ def _apart(eq, v=None):
     
     lst = poly(s.children[0], v)
     
-    lst = [TreeNode("f_eq", [item, tree_form("d_0")]) for item in lst if "v_" in str_form(item)]
+    lst = [simplify(TreeNode("f_eq", [item, tree_form("d_0")])) for item in lst if "v_" in str_form(item)]
     lst2 = []
     for item in lst:
         lst2+=vlist(item)
     origv = list(set(lst2)-set(origv))
     
     out = linear_solve(TreeNode("f_and", lst), [tree_form(item) for item in origv])
+
     for item in out.children:
         
         final3 = replace(final3, tree_form(list(set(vlist(item))&set(origv))[0]), inverse(item.children[0], list(set(vlist(item))&set(origv))[0]))
@@ -139,4 +140,6 @@ def apart(eq):
             return eq2
        
         return TreeNode(eq.name, [helper(child) for child in eq.children])
-    return fx(helper(eq))
+    eq = helper(eq)
+    eq = fx(eq)
+    return eq

mathai/base.py

@@ -1,3 +1,4 @@
+import time
 import copy
 from fractions import Fraction
 def use(eq):
@@ -334,7 +335,7 @@ def vlist(eq):
         out.append(eq.name)
     for child in eq.children:
         out += vlist(child)
-    return sorted(list(set(out)), key=lambda x: int(x[2:]))
+    return list(sorted(list(set(out)), key=lambda x: int(x[2:])))
 def product(lst):
     if lst == []:
         return tree_form("d_1")
@@ -352,6 +353,8 @@ def flatten_tree(node):
         merged_children = []
         for child in node.children:
             flattened_child = flatten_tree(child)
+            if flattened_child is None:
+                return None
             if flattened_child.name == node.name:
                 merged_children.extend(flattened_child.children)
             else:
@@ -360,7 +363,7 @@ def flatten_tree(node):
     else:
         node.children = [flatten_tree(child) for child in node.children]
         return node
-def dowhile(eq, fx):
+def dowhile(eq, fx, start_time=None, budget=None):
     if eq is None:
         return None
     while True:
@@ -368,6 +371,10 @@ def dowhile(eq, fx):
         eq2 = fx(eq)
         if eq2 is None:
             return None
+        if start_time is not None:
+            if -start_time + time.monotonic() > budget:
+              print("timeout")
+              return None
         eq = copy.deepcopy(eq2)
         if eq == orig:
             return orig

mathai/linear.py

@@ -8,7 +8,7 @@ from .base import *
 from .factor import factorconst
 from .tool import poly
 def ss(eq):
-    return dowhile(eq, lambda x: fraction(expand(simplify(x))))
+    return dowhile(eq, lambda x: fraction(simplify(x)))
 def rref(matrix):
     rows, cols = len(matrix), len(matrix[0])
     lead = 0
@@ -34,12 +34,14 @@ def rref(matrix):
     return matrix
 def islinear(eq, fxconst):
     eq =simplify(eq)
-    if all(fxconst(tree_form(item)) and poly(eq, item) is not None and len(poly(eq, item)) <= 2 for item in vlist(eq)):
+    if all(not fxconst(tree_form(item)) or (fxconst(tree_form(item)) and poly(eq, item) is not None and len(poly(eq, item)) <= 2)for item in vlist(eq)):
         return True
+    else:
+        pass
     return False
 def linear(eqlist, fxconst):
     orig = [item.copy_tree() for item in eqlist]
-
+    
     if eqlist == [] or not all(islinear(eq, fxconst) for eq in eqlist):
         return None
 
@@ -53,10 +55,11 @@ def linear(eqlist, fxconst):
     for eq in eqlist:
         varlist(eq, fxconst)
     vl = list(set(vl))
-
+    
     if len(vl) > len(eqlist):
         return TreeNode("f_and", [TreeNode("f_eq", [x, tree_form("d_0")]) for x in eqlist])
     m = []
+    
     for eq in eqlist:
         s = copy.deepcopy(eq)
         row = []
@@ -149,6 +152,7 @@ def linear_solve(eq, lst=None):
     if lst is None:
         out = linear(copy.deepcopy(eqlist), lambda x: "v_" in str_form(x))
     else:
+        
         out = linear(copy.deepcopy(eqlist), lambda x: any(contain(x, item) for item in lst))
     if out is None:
         return None

mathai/logic.py

@@ -1,3 +1,4 @@
+import time
 import itertools
 from .base import *
 def c(eq):
@@ -5,6 +6,35 @@ def c(eq):
      eq = dowhile(eq, logic0)
      eq = dowhile(eq, logic2)
      return eq
+def set_sub(eq):
+  if eq.name == "f_sub":
+    return eq.children[0] & eq.children[1].fx("not")
+  return TreeNode(eq.name, [set_sub(child) for child in eq.children])
+
+start_time = None
+budget = 2.0
+def auto_apply(eq):
+    global start_time
+    fs = [logic1, logic2]
+    results = []
+    pair = 0
+    for g in fs:
+        for f in fs:
+            start_time = time.monotonic()
+            r = dowhile(g(f(eq)), logic0)
+            if r is None:
+                 continue
+            if r != eq:
+                results.append(r)
+            start_time = None
+            pair += 1
+            #print(f"pair {pair}")
+    if not results:
+        return eq
+
+    return min(results, key=lambda x: len(str(x)))
+
+
 def logic_n(eq):
      return dowhile(eq, c)
 def logic0(eq):
@@ -40,6 +70,13 @@ def logic3(eq):
         return TreeNode("f_forall", [eq.children[0], eq.children[1].fx("not")]).fx("not")
     return TreeNode(eq.name, [logic3(child) for child in eq.children])
 def logic2(eq):
+    if eq is None:
+         return None
+    global start_time, budget
+    if start_time is not None:
+         if -start_time + time.monotonic() > budget:
+              #print("timeout")
+              return None
     if eq.name in ["f_exist", "f_forall"]:
         return TreeNode(eq.name, [eq.children[0], logic2(eq.children[1])])
     if eq.name not in ["f_and", "f_or", "f_not", "f_imply", "f_equiv"]:
@@ -111,6 +148,10 @@ def logic2(eq):
 
     if eq.name in ["f_and", "f_or"] and any(child.children is not None and len(child.children)!=0 for child in eq.children):
         for i in range(len(eq.children),1,-1):
+            if start_time is not None:
+                if time.monotonic() - start_time > budget:
+                     
+                    return None
             for item in itertools.combinations(enumerate(eq.children), i):
                 op = "f_and"
                 if eq.name == "f_and":
@@ -148,7 +189,20 @@ def logic2(eq):
                 return output
     return TreeNode(eq.name, [flatten_tree(logic2(child)) for child in eq.children])
 def logic1(eq):
+    if eq is None:
+         return None
+    global start_time, budget
+    if start_time is not None:
+         if time.monotonic() - start_time > budget:
+              #print("timeout")
+              return None
+         else:
+              pass
     def helper(eq):
+        if start_time is not None:
+            if -start_time + time.monotonic() > budget:
+               #print("timeout")
+               return None
         if eq.name in ["f_exist", "f_forall"]:
             return TreeNode(eq.name, [eq.children[0], logic1(eq.children[1])])
         if eq.name not in ["f_and", "f_or", "f_not", "f_imply", "f_equiv"]:
@@ -156,13 +210,17 @@ def logic1(eq):
         if eq.name == "f_equiv":
             A, B = eq.children
             A, B = logic1(A), logic1(B)
-            A, B = dowhile(A, logic2), dowhile(B, logic2)
+            A, B = dowhile(A, logic2, start_time, budget), dowhile(B, logic2, start_time, budget)
+            if A is None or B is None:
+                 return None
             return flatten_tree((A & B) | (A.fx("not") & B.fx("not")))
         if eq.name == "f_imply":
 
             A, B = eq.children
             A, B = logic1(A), logic1(B)
-            A, B = dowhile(A, logic2), dowhile(B, logic2)
+            A, B = dowhile(A, logic2, start_time, budget), dowhile(B, logic2, start_time, budget)
+            if A is None or B is None:
+                 return None
             return flatten_tree(A.fx("not") | B)
         return TreeNode(eq.name, [helper(child) for child in eq.children])
     if eq.name in ["f_exist", "f_forall"]:
@@ -171,30 +229,27 @@ def logic1(eq):
         return eq
     eq = helper(eq)
     eq = flatten_tree(eq)
-
     if len(eq.children) > 2:
         lst = []
         l = len(eq.children)
-
         if l % 2 == 1:
             last_child = eq.children[-1]
 
             if isinstance(last_child, TreeNode):
-                last_child = dowhile(last_child, logic2)
+                last_child = dowhile(last_child, logic2, start_time, budget)
             lst.append(last_child)
             l -= 1
 
         for i in range(0, l, 2):
             left, right = eq.children[i], eq.children[i+1]
             pair = TreeNode(eq.name, [left, right])
-            simplified = dowhile(logic1(pair), logic2)
+            simplified = dowhile(logic1(pair), logic2, start_time, budget)
             lst.append(simplified)
 
         if len(lst) == 1:
             return flatten_tree(lst[0])
 
         return flatten_tree(TreeNode(eq.name, lst))
-
     if eq.name == "f_and":
         lst= []
         for child in eq.children:
@@ -224,4 +279,3 @@ def logic1(eq):
             out = out.children[0]
         return flatten_tree(out)
     return TreeNode(eq.name, [logic1(child) for child in eq.children])
-

{mathai-0.8.0.dist-info → mathai-0.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.8.0
+Version: 0.8.2
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai4
 Requires-Python: >=3.7

{mathai-0.8.0.dist-info → mathai-0.8.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
-mathai/__init__.py,sha256=JdRPSes54qhzvi6f8Rni2sXljzzirrWZsaCmu9W9rws,1525
-mathai/apart.py,sha256=VSS3khE9PNuxiRvdU5JDl4IN-KJBSIFjwR17pkhviXI,4197
-mathai/base.py,sha256=zha7eOnfLjJuQcwi29rE0588U1R8v-0zulVPatr2aQo,14843
+mathai/__init__.py,sha256=MX8bkJQ_MOk0fkoCo3r3g5Kwt4zMx9g5M6i64p5kH18,1576
+mathai/apart.py,sha256=CbCX4pAWIaJgu21wZcW9XdEf82oXgxmtTyD3tUI31Ls,4235
+mathai/base.py,sha256=W_Lk9hQp4wTzF4H5DQLsb8O_HAE6bfqgjqHvWJOMJb8,15114
 mathai/bivariate_inequality.py,sha256=Da-A1kqVynR0tNOlEI7GSTf5T2vNkcF4etL9-EoyPJg,11415
 mathai/diff.py,sha256=GEiAGMCTT0dO-ULTUGvTlBKy-Io-r2xcgvFJfmqGurY,6879
 mathai/expand.py,sha256=yioVkQrtCz1fC8npcnokN1WwvJlGxrO1D4aKn8F8ky0,1757
@@ -9,8 +9,8 @@ mathai/fraction.py,sha256=44RuEPQ8z2CGhnxFXrHIy4MkgaE4QDtu7-sEV12GWjc,2597
 mathai/integrate.py,sha256=6Ik_uAzkLyOWCE9M7mqwH_SVTvEdiG0-UYS2KsDgjLI,17454
 mathai/inverse.py,sha256=ya7P8WjzfaAL3UXL7xqOh5GaIsXLDZ-F6lZFy3IEgaQ,2931
 mathai/limit.py,sha256=9F8i9UZh2xb-V8A5Sd1gdhDf9c2RFgpE1GdNn9MvbWI,5703
-mathai/linear.py,sha256=36mcYq2mzSidxC2F9gmaMHrXO9vNHYH9kX8CNsopyW8,5145
-mathai/logic.py,sha256=wUenUEcIazQH2jnka43QQ9XpLQgY7x3Rq2QUxzFzf-U,9569
+mathai/linear.py,sha256=pTo4gXyosUnwG6h5G1zZOMCJPwQaBZyuaeH8XlrBy9o,5219
+mathai/logic.py,sha256=-riPN3SI0gv53u2jlHY81onlN0NfPXDOpyJszATLZOQ,11353
 mathai/matrix.py,sha256=k8gIasxtEF1t_B0mJSbDvUJ3FDddvYI8hhy0FMMQ54k,5416
 mathai/ode.py,sha256=F0Z_Zv2YsnVf4HwIJmqvIenjONaItzy5H739THkLvcU,11616
 mathai/parser.py,sha256=vXpDobXd6de3-1zdeXVDcZ817oiGM_o2RoVwgUc4U9s,6785
@@ -22,7 +22,7 @@ mathai/structure.py,sha256=u4usB0yPnem2VscgEBqKWxRN9Y4tTjymEaQh1de5Bsk,4121
 mathai/tool.py,sha256=Wjp8pcBu7MkJr-oAa_bFzKr9mNAB9WrpPISSJd4p-x0,5407
 mathai/trig.py,sha256=tkn6NgfXj5XzjVB261SuX_mx2g3stqNksoco4O6so90,10713
 mathai/univariate_inequality.py,sha256=QoE6lZW_cUXa5sbbvwz88DjAVSY--RZt03w02edCVtA,16375
-mathai-0.8.0.dist-info/METADATA,sha256=RaL-uVubiBKVs7rz5DdcPKe9ri9Ihe0llTv6bA-7ElY,7735
-mathai-0.8.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mathai-0.8.0.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.8.0.dist-info/RECORD,,
+mathai-0.8.2.dist-info/METADATA,sha256=7pNC30dw3ZaFDHm2q_CNxEZ5E5CUtUPF7T9YYJahyqY,7735
+mathai-0.8.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mathai-0.8.2.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.8.2.dist-info/RECORD,,