mathai 0.3.3__tar.gz → 0.3.5__tar.gz

{mathai-0.3.3 → mathai-0.3.5}/PKG-INFO

@@ -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 → mathai-0.3.5}/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-0.3.5/mathai/search.py

@@ -0,0 +1,117 @@
+from mathai import *
+import copy
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+
+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)
+
+        # Thinking message
+        printeq(current_eq)
+
+        # Immediate termination using predicate functions
+        if true_expr(current_eq):
+            found_boolean = True
+            boolean_path = path
+            boolean_expr = current_eq
+            break
+        if false_expr(current_eq):
+            found_boolean = True
+            boolean_path = path
+            boolean_expr = current_eq
+            break
+
+
+        # 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=timeout)
+                new_expr_str = str(new_expr)
+                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)]))
+                consecutive_timeouts = 0  # reset after success
+            except TimeoutError:
+                print(f"[Thinking] {fx.__name__} timed out, skipping.")
+                consecutive_timeouts += 1
+                continue
+
+        # 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 → mathai-0.3.5}/mathai.egg-info/PKG-INFO

@@ -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 → mathai-0.3.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="0.3.3",
+    version="0.3.5",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

mathai-0.3.3/mathai/search.py

@@ -1,108 +0,0 @@
-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)
-
-    # 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
-
-    # 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]
-
-    # 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 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:")
-            printeq(current_eq)
-            future = executor.submit(fx, current_eq)
-            try:
-                new_expr = future.result(timeout=5)
-                new_expr_str = str(new_expr)
-                if new_expr_str != expr_str:
-                    stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-                    break  # only take one growing function
-            except TimeoutError:
-                print(f"[Thinking] {fx.__name__} (growing) timed out, skipping.")
-                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)