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

mathai/search.py

@@ -2,110 +2,107 @@ 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)
+# Original expression
+original_eq = simplify(parse("((P|~Q)&(P&~Q|P&R)&(~P&~R|~Q))<->P&~Q"))
 
-        # Thinking message
-        printeq(current_eq)
+# 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
 
-        # 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
+# 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
 
-        # 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):")
+    # 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=timeout)
+                new_expr = future.result(timeout=5)
                 new_expr_str = str(new_expr)
-                if len(new_expr_str) <= len(expr_str) and new_expr_str != expr_str:
-                    reduced_any = True
+                if new_expr_str != expr_str:
                     stack.append((new_expr, path + [copy.deepcopy(new_expr)]))
-                consecutive_timeouts = 0  # reset after success
+                    break  # only take one growing function
             except TimeoutError:
-                print(f"[Thinking] {fx.__name__} timed out, skipping.")
-                consecutive_timeouts += 1
+                print(f"[Thinking] {fx.__name__} (growing) timed out, skipping.")
                 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
+# 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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 0.3.2
+Version: 0.3.3
 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.2.dist-info → mathai-0.3.3.dist-info}/RECORD

@@ -13,13 +13,13 @@ 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=7YH39WN3pZsGdMfA-dXUSZalc0Orz3kI9fDLaegvV10,4617
+mathai/search.py,sha256=BmUKacCpptIoyUObB0hknAbgFs8EPQXXXXYBXT40Luc,3672
 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.2.dist-info/METADATA,sha256=W7S3gfDUvWikgK0fKYEabca7ro93RTDjk9KThhmUvCI,7021
-mathai-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mathai-0.3.2.dist-info/top_level.txt,sha256=ROP4l3OhGYw3ihkQGASr18xM9GsK4z3_6whV5AyXLwE,7
-mathai-0.3.2.dist-info/RECORD,,
+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,,