mathai 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

mathai/integrate.py

@@ -376,24 +376,25 @@ def rm_const(equation):
                 return rm_const(TreeNode("f_integrate",[equation, wrt])) *const
         equation = eq2
     return TreeNode(equation.name, [rm_const(child)  for child in equation.children])
+
 def integrate_formula(equation):
     if equation.name == "f_ref":
-        return equation
+        return equation.copy_tree()
     eq2 = equation.copy_tree()
     if eq2.name == "f_integrate":
-        equation = eq2.children[0]
+        integrand = eq2.children[0]
         wrt = eq2.children[1]
-        if equation == wrt:
-            return equation**2/2
-        if not contain(equation,wrt):
-            return wrt*equation
-        out = transform_formula(simplify(trig0(equation)), wrt.name, formula_gen[0], formula_gen[1], formula_gen[2])
+        if integrand == wrt:
+            return TreeNode("f_add", [TreeNode("f_power", [wrt.copy_tree(), TreeNode("2")]), TreeNode("f_div", [TreeNode("1"), TreeNode("2")])])  # x^2/2
+        if not contain(integrand, wrt):
+            return TreeNode("f_mul", [wrt.copy_tree(), integrand.copy_tree()])  # constant * dx
+        out = transform_formula(simplify(trig0(integrand)), wrt.name, formula_gen[0], formula_gen[1], formula_gen[2])
         if out is not None:
             return out
-        
-        if str_form(equation).count("f_sin")+str_form(equation).count("f_cos")>2:
-                out = transform_formula(equation, wrt.name, formula_gen4[0], formula_gen4[1], formula_gen4[2])
-                if out is not None:
-                    return out
-        equation = eq2
-    return TreeNode(equation.name, [integrate_formula(child)  for child in equation.children])
+        expr_str = str_form(integrand)
+        if expr_str.count("f_sin") + expr_str.count("f_cos") > 2:
+            out = transform_formula(integrand, wrt.name, formula_gen4[0], formula_gen4[1], formula_gen4[2])
+            if out is not None:
+                return out
+    return TreeNode(eq2.name, [integrate_formula(child) for child in eq2.children])
+

mathai/search.py

@@ -2,107 +2,116 @@ from mathai import *
 import copy
 from concurrent.futures import ThreadPoolExecutor, TimeoutError
 
-# Original expression
-original_eq = simplify(parse("((P|~Q)&(P&~Q|P&R)&(~P&~R|~Q))<->P&~Q"))
-
-# Simplification functions
-lst = [logic1, logic3, logic2]
-
-MAX_SMALL = 2
-smallest_four = []
-
-# Stack element: (current_expr, path_list)
-stack = [(copy.deepcopy(original_eq), [copy.deepcopy(original_eq)])]
-
-# Keep track of visited expressions to prevent cycles
-visited = set()
-
-# Boolean constants for immediate termination
-TRUE_EXPR = tree_form("s_true")
-FALSE_EXPR = tree_form("s_false")
-
-found_boolean = False
-boolean_path = None
-boolean_expr = None
-
-# Thread pool executor
-executor = ThreadPoolExecutor(max_workers=3)
-
-while stack and not found_boolean:
-    current_eq, path = stack.pop()
-    expr_str = str(current_eq)
-
-    if expr_str in visited:
-        continue
-    visited.add(expr_str)
-
-    # Thinking message
-    printeq(current_eq)
+def dfs_simplify(equation, functions, true_expr, false_expr,
+                 max_timeout=25, max_small=4,
+                 base_timeout=1, time_per_char=0.1, timeout_increase=0.5):
+    """
+    Perform DFS simplification on a given equation using provided functions.
+
+    Args:
+        equation: The starting expression (TreeNode or parsed equation)
+        functions: List of simplification functions
+        true_expr: Expression representing True (immediate termination)
+        false_expr: Expression representing False (immediate termination)
+        max_timeout: Maximum timeout allowed for any function
+        max_small: Number of smallest expressions to track
+        base_timeout: Base timeout in seconds
+        time_per_char: Additional timeout per character of expression
+        timeout_increase: Factor to increase timeout for consecutive timeouts
+
+    Returns:
+        tuple(found_boolean, boolean_path, smallest_expressions)
+    """
+    original_eq = simplify(equation)
+    smallest_four = []
+
+    stack = [(copy.deepcopy(original_eq), [copy.deepcopy(original_eq)])]
+    visited = set()
+
+    found_boolean = False
+    boolean_path = None
+    boolean_expr = None
+
+    executor = ThreadPoolExecutor(max_workers=3)
+    consecutive_timeouts = 0
+
+    while stack and not found_boolean:
+        current_eq, path = stack.pop()
+        expr_str = str(current_eq)
+
+        if expr_str in visited:
+            continue
+        visited.add(expr_str)
 
-    # Immediate termination for boolean constants
-    if current_eq == TRUE_EXPR or current_eq == FALSE_EXPR:
-        found_boolean = True
-        boolean_path = path
-        boolean_expr = current_eq
-        break
+        # Thinking message
+        printeq(current_eq)
 
-    # Insert into smallest_four if qualifies
-    inserted = False
-    for j in range(len(smallest_four)):
-        if len(expr_str) < len(str(smallest_four[j][0])):
-            smallest_four.insert(j, (copy.deepcopy(current_eq), copy.deepcopy(path)))
-            inserted = True
+        # Immediate termination using predicate functions
+        if true_expr(current_eq):
+            found_boolean = True
+            boolean_path = path
+            boolean_expr = current_eq
             break
-    if not inserted and len(smallest_four) < MAX_SMALL:
-        smallest_four.append((copy.deepcopy(current_eq), copy.deepcopy(path)))
-    if len(smallest_four) > MAX_SMALL:
-        smallest_four = smallest_four[:MAX_SMALL]
-
-    # First, try functions that reduce length
-    reduced_any = False
-    for fx in lst:
-        print(f"[Thinking] Executing {fx.__name__} on current expression:")
-        printeq(current_eq)
-        future = executor.submit(fx, current_eq)
-        try:
-            new_expr = future.result(timeout=5)
-            new_expr_str = str(new_expr)
-            # Only accept if shorter or equal
-            if len(new_expr_str) <= len(expr_str) and new_expr_str != expr_str:
-                reduced_any = True
-                stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-        except TimeoutError:
-            print(f"[Thinking] {fx.__name__} timed out, skipping.")
-            continue
+        if false_expr(current_eq):
+            found_boolean = True
+            boolean_path = path
+            boolean_expr = current_eq
+            break
+
 
-    # If no reducing function produced a shorter or equal expression, try a “growing” function
-    if not reduced_any:
-        for fx in lst:
-            print(f"[Thinking] Trying growing {fx.__name__} on current expression:")
+        # Insert into smallest_four if qualifies
+        inserted = False
+        for j in range(len(smallest_four)):
+            if len(expr_str) < len(str(smallest_four[j][0])):
+                smallest_four.insert(j, (copy.deepcopy(current_eq), copy.deepcopy(path)))
+                inserted = True
+                break
+        if not inserted and len(smallest_four) < max_small:
+            smallest_four.append((copy.deepcopy(current_eq), copy.deepcopy(path)))
+        if len(smallest_four) > max_small:
+            smallest_four = smallest_four[:max_small]
+
+        # Calculate adaptive timeout with cap
+        timeout = (base_timeout + time_per_char * len(expr_str)) * (1 + timeout_increase * consecutive_timeouts)
+        if timeout > max_timeout:
+            timeout = max_timeout
+
+        # Try functions that reduce length first
+        reduced_any = False
+        for fx in functions:
+            print(f"[Thinking] Executing {fx.__name__} on current expression (timeout={timeout:.2f}s):")
             printeq(current_eq)
             future = executor.submit(fx, current_eq)
             try:
-                new_expr = future.result(timeout=5)
+                new_expr = future.result(timeout=timeout)
                 new_expr_str = str(new_expr)
-                if new_expr_str != expr_str:
+                if len(new_expr_str) <= len(expr_str) and new_expr_str != expr_str:
+                    reduced_any = True
                     stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-                    break  # only take one growing function
+                consecutive_timeouts = 0  # reset after success
             except TimeoutError:
-                print(f"[Thinking] {fx.__name__} (growing) timed out, skipping.")
+                print(f"[Thinking] {fx.__name__} timed out, skipping.")
+                consecutive_timeouts += 1
                 continue
 
-# Shutdown executor
-executor.shutdown(wait=True)
-
-# Display final results
-if found_boolean:
-    print("\nBoolean constant found! Full path to solution:\n")
-    for step in boolean_path:
-        printeq(step)
-else:
-    print("\nDFS completed. Two smallest expressions with steps:\n")
-    for expr, path in smallest_four:
-        print("Path to final expression:")
-        for step in path:
-            printeq(step)
-        print("-"*50)
+        # If no reducing function worked, try growing functions
+        if not reduced_any:
+            for fx in functions:
+                print(f"[Thinking] Trying growing {fx.__name__} on current expression (timeout={timeout:.2f}s):")
+                printeq(current_eq)
+                future = executor.submit(fx, current_eq)
+                try:
+                    new_expr = future.result(timeout=timeout)
+                    new_expr_str = str(new_expr)
+                    if new_expr_str != expr_str:
+                        stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
+                        consecutive_timeouts = 0
+                        break  # only take one growing function
+                except TimeoutError:
+                    print(f"[Thinking] {fx.__name__} (growing) timed out, skipping.")
+                    consecutive_timeouts += 1
+                    continue
+
+    executor.shutdown(wait=True)
+
+    return found_boolean, boolean_path, smallest_four

{mathai-0.3.3.dist-info → mathai-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.3.3
+Version: 0.3.5
 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

{mathai-0.3.3.dist-info → mathai-0.3.5.dist-info}/RECORD

@@ -6,20 +6,20 @@ mathai/diff.py,sha256=YUBpRsz0qmBkq5vGxeGnvR4nMKjdOQiIXlNMxpij2ns,3051
 mathai/expand.py,sha256=SnBltkpIENMGkP0AYmbMlSc4H-CF5RslO2PcBEkn1BQ,3359
 mathai/factor.py,sha256=NPXxET52TacNExuvw6p1jbC6g3wY6_VOCdlGlexXZio,5916
 mathai/fraction.py,sha256=Q2ztsh5Bpz6YhML2QU0tfufbAs0Q6J319AhlzKephIY,4396
-mathai/integrate.py,sha256=85qM7nvALtYjVMp17Tx5Kvevdz0d1UPDKQBBTnDqgrs,14828
+mathai/integrate.py,sha256=1E6Uv0f6aqQHB1vmrgvhApw2vtb13upThOKptk891LA,15002
 mathai/inverse.py,sha256=QCvDrzKquWsZv-BDAzZd9HnU0c3gZvcc44UztHVO5LQ,2919
 mathai/limit.py,sha256=RA8YAehgYCGVWv9qBc8uQ34BQ9mFthWl2OrVTwcHl2g,4920
 mathai/linear.py,sha256=wyiLpIxRDmD96xXktkgvc5gegIB3zblLB1EuV3TFdmU,5474
 mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
 mathai/parser.py,sha256=f7bemieFmp0sbup1NlraMLvZDVFvqKGFknEVtlFRMVk,6979
 mathai/printeq.py,sha256=gIes-pstFOa6FcnpVIVvkjVKuWdsVdo11LlEnmHhakU,1303
-mathai/search.py,sha256=BmUKacCpptIoyUObB0hknAbgFs8EPQXXXXYBXT40Luc,3672
+mathai/search.py,sha256=6S_V0PrC2ZnbhkWyT2ZTtExRD_mDlo-C3p0TDn6Dk3w,4743
 mathai/simplify.py,sha256=F37h-Z_rW35uVgx0G86vQErU2Ac6ZiTBN9KcC3RzDkg,15156
 mathai/structure.py,sha256=4Ww2IAx62RcQSO7_17TZES-DjMWBpcFQtL939FBIHwY,4103
 mathai/tool.py,sha256=UyccamiJy_CkFPakfufyPzdhtlEO6v2D7qwbXQ9V7Rg,2000
 mathai/trig.py,sha256=5P0RNS4eetNds2l-wyA4BAKqJdFIUws_8RGS_dH7gp8,9348
 mathai/univariate_inequality.py,sha256=_r-kkiS4Hr-jRN7f-EL_E4svAMFWJP1Ea50HJKKbjfk,14778
-mathai-0.3.3.dist-info/METADATA,sha256=mlSi3WdczR0cSSetNJUPeJE7v9EAHJY-wTjKFbvRtsg,7021
-mathai-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mathai-0.3.3.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.3.3.dist-info/RECORD,,
+mathai-0.3.5.dist-info/METADATA,sha256=fKwgikKrsCYSz8fRhFqIOJY71JITj1PLuFgM_GEKpFY,7021
+mathai-0.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mathai-0.3.5.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.3.5.dist-info/RECORD,,