mathai 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

mathai/__init__.py

@@ -12,5 +12,6 @@ from .logic import logic0, logic1, logic2, logic3
 from .apart import apart
 from .console import console
 from .limit import limit
+from .search import dfs_simplify
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt
 from .base import *

mathai/search.py

@@ -0,0 +1,111 @@
+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 for provided boolean expressions
+        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]
+
+        # 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/simplify.py

@@ -149,7 +149,7 @@ def solve2(eq):
 def clear_div(eq, denom=False):
     lst = factor_generation(eq)
     if tree_form("d_0") in lst:
-        return tree_form("d_0")
+        return tree_form("d_0"), True
     lst3 = [item for item in lst if "v_" not in str_form(item) and compute(item) < 0]
     
     sign = True

{mathai-0.3.0.dist-info → mathai-0.3.1.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-mathai/__init__.py,sha256=1e8IUnfQv45U_EIp4GS_ugwVQlqQPWoWn3td5pTF5Lk,615
+mathai/__init__.py,sha256=OrSjLAAeRQrr4eHcOZFtU56gRIjukNKnsEaDnYiZjrk,649
 mathai/apart.py,sha256=P0B21wHUFitc5RGbNJlwSeOdseOMcav4I7teFNcZmFA,3130
 mathai/base.py,sha256=l8p8nkCuBDUISI5whtxIuZnOHyFn7F29mLXeKtWWWFQ,12392
 mathai/console.py,sha256=FsEMqDsgFeBSUiPCm9sfReZp56NSyoFVldqmVwvW4lg,3119
@@ -13,12 +13,13 @@ mathai/linear.py,sha256=eVnDbJYC1TWwg4J7ovBKsaHYlSoDmXk5jQpsqwtVPyI,5481
 mathai/logic.py,sha256=UvHzRmKcO9AD51tRzHmpNSEhgW5gmaf4XPaQKFjGfC4,9653
 mathai/parser.py,sha256=aDaF1-tqJHZI4znAcHUSEbz7pPVnvHItOMZ2lp7Vxww,6940
 mathai/printeq.py,sha256=JTB0_RBcgt1yFviqlHtXGXuSXcpKrxzSxj5WHkOHon4,1318
-mathai/simplify.py,sha256=FZrQkG-dhUJqD-V856139Ogj2SAQQ8pNkvUCyfTwZr0,15034
+mathai/search.py,sha256=7YH39WN3pZsGdMfA-dXUSZalc0Orz3kI9fDLaegvV10,4617
+mathai/simplify.py,sha256=NymYVFocnpY8T-LJkyvQPddoF5avUgm3T-JzzRC1R3w,15040
 mathai/structure.py,sha256=Hgw2y43dwasa6G8z6OS2lmReh7JHwlChGn-FUdEaWY8,4106
 mathai/tool.py,sha256=87N5Ya7DmHdFOobTYDAjPHNWZuMzMIDjYN0ZtlHjxqE,1099
 mathai/trig.py,sha256=ywu89MJfAB81JCzsVPBLpGGv8od0LhLn5cgDtLtYwmw,6897
 mathai/univariate_inequality.py,sha256=_r-kkiS4Hr-jRN7f-EL_E4svAMFWJP1Ea50HJKKbjfk,14778
-mathai-0.3.0.dist-info/METADATA,sha256=SvdOmm8n5BQHeXmZeyCBbSBYrJ_MfFLuw4YS1Ljc2jg,7087
-mathai-0.3.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mathai-0.3.0.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.3.0.dist-info/RECORD,,
+mathai-0.3.1.dist-info/METADATA,sha256=hsbiZmYg6R_9C2NVmr7rh0g03RuOArr-CZ9r0WJQB80,7087
+mathai-0.3.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mathai-0.3.1.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
+mathai-0.3.1.dist-info/RECORD,,