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

mathai/parser.py

@@ -1,154 +1,158 @@
-import copy
-from lark import Lark, Tree
-from .base import *
-import re
-
-grammar = """
-?start: expr
-
-?expr: logic_equiv
-
-?logic_equiv: logic_imply
-            | logic_equiv "<->" logic_imply  -> equiv
-
-?logic_imply: logic_or
-            | logic_or "->" logic_imply      -> imply
-
-?logic_or: logic_and
-         | logic_or "|" logic_and            -> or
-         | logic_or "||" logic_and           -> or
-
-?logic_and: comparison
-          | logic_and "&" comparison         -> and
-          | logic_and "&&" comparison        -> and
-
-?comparison: arithmetic
-           | comparison "=" arithmetic  -> eq
-           | comparison "<" arithmetic  -> lt
-           | comparison ">" arithmetic  -> gt
-           | comparison "<=" arithmetic -> le
-           | comparison ">=" arithmetic -> ge
-
-?arithmetic: arithmetic "+" term   -> add
-           | arithmetic "-" term   -> sub
-           | term
-
-?term: term "*" power  -> mul
-     | term "/" power  -> div
-     | term "." power  -> dot
-     | power
-
-?power: power "^" factor   -> pow
-      | power "**" factor  -> pow
-      | factor
-
-?factor: "-" factor        -> neg
-       | "+" factor        -> pass_through
-       | atom
-
-?atom: NUMBER               -> number
-     | VARIABLE             -> variable
-     | FUNC_NAME "(" [expr ("," expr)*] ")" -> func
-     | "[" [expr ("," expr)*] "]"           -> list
-     | "(" expr ")"        -> paren
-     | CNUMBER             -> cnumber
-     | ESCAPED_STRING      -> string
-     | CAPITAL_ID          -> matrix
-
-FUNC_NAME: "midpoint" | "forall" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
-
-VARIABLE: /[a-z]/ | "nabla" | "pi" | "kc" | "hbar" | "em" | "ec" | "anot" | "false" | "true"
-
-CAPITAL_ID: /[A-Z]/
-
-CNUMBER: /c[0-9]+/
-
-%import common.NUMBER
-%import common.ESCAPED_STRING
-%import common.WS_INLINE
-%ignore WS_INLINE
-"""
-
-def parse(equation, funclist=None):
-    equation = copy.copy(equation.replace(" ", ""))
-    grammar2 = copy.deepcopy(grammar)
-    if funclist is not None:
-        output = grammar2.split("\n")
-        for i in range(len(output)):
-            if "FUNC_NAME:" in output[i]:
-                output[i] = output[i].replace("FUNC_NAME: ", "FUNC_NAME: " + " | ".join(['"' + x + '"' for x in funclist]) + " | ")
-        grammar2 = "\n".join(output)
-
-    parser_main = Lark(grammar2, start='start', parser='lalr')
-    parse_tree = parser_main.parse(equation)
-
-    # Convert Lark tree to TreeNode
-    def convert_to_treenode(parse_tree):
-        if isinstance(parse_tree, Tree):
-            node = TreeNode(parse_tree.data)
-            node.children = [convert_to_treenode(child) for child in parse_tree.children]
-            return node
-        else:
-            return TreeNode(str(parse_tree))
-
-    # Flatten unnecessary nodes like pass_through
-    def remove_past(equation):
-        if equation.name in {"number", "paren", "func", "variable", "pass_through", "cnumber", "string", "matrix"}:
-            if len(equation.children) == 1:
-                return remove_past(equation.children[0])
-            else:
-                equation.children = [remove_past(child) for child in equation.children]
-                return TreeNode(equation.children[0].name, equation.children[1:])
-        equation.children = [remove_past(child) for child in equation.children]
-        return equation
-
-    # Handle indices if any
-    def prefixindex(equation):
-        if equation.name == "base" and len(equation.children) > 1:
-            return TreeNode("index", [equation.children[0]] + equation.children[1].children)
-        return TreeNode(equation.name, [prefixindex(child) for child in equation.children])
-
-    tree_node = convert_to_treenode(parse_tree)
-    tree_node = remove_past(tree_node)
-    tree_node = prefixindex(tree_node)
-
-    # Convert function names and constants
-    def fxchange(tree_node):
-        tmp3 = funclist if funclist is not None else []
-        if tree_node.name == "neg":
-            child = fxchange(tree_node.children[0])
-            # if the child is a number, make it negative
-            if child.name.startswith("d_") and re.match(r"d_\d+(\.\d+)?$", child.name):
-                return TreeNode("d_" + str(-int(child.name[2:])))
-            else:
-                # otherwise subtract from zero
-                return TreeNode("f_sub", [tree_form("d_0"), child])
-        if tree_node.name == "pass_through":
-            return fxchange(tree_node.children[0])
-        return TreeNode(
-            "f_" + tree_node.name if tree_node.name in tmp3 + ["sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
-            [fxchange(child) for child in tree_node.children]
-        )
-
-    tree_node = fxchange(tree_node)
-
-    # Replace common constants
-    for const in ["e","pi","kc","em","ec","anot","hbar","false","true","i","nabla"]:
-        tree_node = replace(tree_node, tree_form("d_"+const), tree_form("s_"+const))
-
-    # Map letters to variables
-    for i, c in enumerate(["x","y","z"] + [chr(x+ord("a")) for x in range(0,23)]):
-        tree_node = replace(tree_node, tree_form("d_"+c), tree_form("v_"+str(i)))
-    for i, c in enumerate([chr(x+ord("A")) for x in range(0,26)]):
-        tree_node = replace(tree_node, tree_form("d_"+c), tree_form("v_-"+str(i+1)))
-        tree_node = replace(tree_node, tree_form("f_"+c), tree_form("v_-"+str(i+1)))
-
-    # Final recursive replacements
-    def rfx(tree_node):
-        if tree_node.name[:3] == "d_c":
-            return tree_form("v_" + str(int(tree_node.name[3:])+100))
-        tree_node.children = [rfx(child) for child in tree_node.children]
-        return tree_node
-
-    tree_node = rfx(tree_node)
-    return tree_node
+import copy
+from lark import Lark, Tree
+from .base import *
+import re
+
+grammar = """
+?start: expr
+
+?expr: logic_equiv
+
+?logic_equiv: logic_imply
+            | logic_equiv "<->" logic_imply  -> equiv
+
+?logic_imply: logic_or
+            | logic_or "->" logic_imply      -> imply
+
+?logic_or: logic_and
+         | logic_or "|" logic_and            -> or
+         | logic_or "||" logic_and           -> or
+
+?logic_and: logic_not
+          | logic_and "&" logic_not          -> and
+          | logic_and "&&" logic_not         -> and
+
+?logic_not: comparison
+          | "!" logic_not                    -> not
+          | "~" logic_not                    -> not
+
+?comparison: arithmetic
+           | comparison "=" arithmetic  -> eq
+           | comparison "<" arithmetic  -> lt
+           | comparison ">" arithmetic  -> gt
+           | comparison "<=" arithmetic -> le
+           | comparison ">=" arithmetic -> ge
+
+?arithmetic: arithmetic "+" term   -> add
+           | arithmetic "-" term   -> sub
+           | term
+
+?term: term "*" power  -> mul
+     | term "/" power  -> div
+     | term "." power  -> dot
+     | power
+
+?power: power "^" factor   -> pow
+      | power "**" factor  -> pow
+      | factor
+
+?factor: "-" factor        -> neg
+       | "+" factor        -> pass_through
+       | atom
+
+?atom: NUMBER               -> number
+     | VARIABLE             -> variable
+     | FUNC_NAME "(" [expr ("," expr)*] ")" -> func
+     | "[" [expr ("," expr)*] "]"           -> list
+     | "(" expr ")"        -> paren
+     | CNUMBER             -> cnumber
+     | ESCAPED_STRING      -> string
+     | CAPITAL_ID          -> matrix
+
+FUNC_NAME: "midpoint" | "forall" | "imply" | "exist" | "len" | "sum" | "angle" | "line" | "sum2" | "charge" | "electricfield" | "perm" | "point" | "equationrhs" | "transpose" | "equationlhs" | "equation" | "error" | "covariance" | "variance" | "expect" | "mag" | "rad" | "laplace" | "diverge" | "pdif" | "gradient" | "curl" | "point1" | "point2" | "dot" | "point3" | "line1" | "line2" | "line3" | "sin" | "circumcenter" | "eqtri" | "linesegment" | "cos" | "tan" | "log" | "sqrt" | "integrate" | "dif" | "abs" | "cosec" | "sec" | "cot" | "arctan" | "arcsin" | "arccos" | "log10"
+
+VARIABLE: /[a-z]/ | "nabla" | "pi" | "kc" | "hbar" | "em" | "ec" | "anot" | "false" | "true"
+
+CAPITAL_ID: /[A-Z]/
+
+CNUMBER: /c[0-9]+/
+
+%import common.NUMBER
+%import common.ESCAPED_STRING
+%import common.WS_INLINE
+%ignore WS_INLINE
+"""
+
+def parse(equation, funclist=None):
+    equation = copy.copy(equation.replace(" ", ""))
+    grammar2 = copy.deepcopy(grammar)
+    if funclist is not None:
+        output = grammar2.split("\n")
+        for i in range(len(output)):
+            if "FUNC_NAME:" in output[i]:
+                output[i] = output[i].replace("FUNC_NAME: ", "FUNC_NAME: " + " | ".join(['"' + x + '"' for x in funclist]) + " | ")
+        grammar2 = "\n".join(output)
+
+    parser_main = Lark(grammar2, start='start', parser='lalr')
+    parse_tree = parser_main.parse(equation)
+
+    # Convert Lark tree to TreeNode
+    def convert_to_treenode(parse_tree):
+        if isinstance(parse_tree, Tree):
+            node = TreeNode(parse_tree.data)
+            node.children = [convert_to_treenode(child) for child in parse_tree.children]
+            return node
+        else:
+            return TreeNode(str(parse_tree))
+
+    # Flatten unnecessary nodes like pass_through
+    def remove_past(equation):
+        if equation.name in {"number", "paren", "func", "variable", "pass_through", "cnumber", "string", "matrix"}:
+            if len(equation.children) == 1:
+                return remove_past(equation.children[0])
+            else:
+                equation.children = [remove_past(child) for child in equation.children]
+                return TreeNode(equation.children[0].name, equation.children[1:])
+        equation.children = [remove_past(child) for child in equation.children]
+        return equation
+
+    # Handle indices if any
+    def prefixindex(equation):
+        if equation.name == "base" and len(equation.children) > 1:
+            return TreeNode("index", [equation.children[0]] + equation.children[1].children)
+        return TreeNode(equation.name, [prefixindex(child) for child in equation.children])
+
+    tree_node = convert_to_treenode(parse_tree)
+    tree_node = remove_past(tree_node)
+    tree_node = prefixindex(tree_node)
+
+    # Convert function names and constants
+    def fxchange(tree_node):
+        tmp3 = funclist if funclist is not None else []
+        if tree_node.name == "neg":
+            child = fxchange(tree_node.children[0])
+            # if the child is a number, make it negative
+            if child.name.startswith("d_") and re.match(r"d_\d+(\.\d+)?$", child.name):
+                return TreeNode("d_" + str(-int(child.name[2:])))
+            else:
+                # otherwise subtract from zero
+                return TreeNode("f_sub", [tree_form("d_0"), child])
+        if tree_node.name == "pass_through":
+            return fxchange(tree_node.children[0])
+        return TreeNode(
+            "f_" + tree_node.name if tree_node.name in tmp3 + ["sqrt","imply","forall","exist","exclude","union","intersection","len","index","angle","charge","sum2","electricfield","line","point","sum","transpose","equationrhs","equationlhs","equation","covariance","variance","expect","error","laplace","dot","curl","pdif","diverge","gradient","rad","ge","le","gt","lt","eqtri","linesegment","midpoint","mag","point1","point2","point3","line1","line2","line3","log10","arcsin","arccos","arctan","list","cosec","sec","cot","equiv","or","not","and","circumcenter","eq","sub","add","sin","cos","tan","mul","integrate","dif","pow","div","log","abs"] else "d_" + tree_node.name,
+            [fxchange(child) for child in tree_node.children]
+        )
+
+    tree_node = fxchange(tree_node)
+
+    # Replace common constants
+    for const in ["e","pi","kc","em","ec","anot","hbar","false","true","i","nabla"]:
+        tree_node = replace(tree_node, tree_form("d_"+const), tree_form("s_"+const))
+
+    # Map letters to variables
+    for i, c in enumerate(["x","y","z"] + [chr(x+ord("a")) for x in range(0,23)]):
+        tree_node = replace(tree_node, tree_form("d_"+c), tree_form("v_"+str(i)))
+    for i, c in enumerate([chr(x+ord("A")) for x in range(0,26)]):
+        tree_node = replace(tree_node, tree_form("d_"+c), tree_form("v_-"+str(i+1)))
+        tree_node = replace(tree_node, tree_form("f_"+c), tree_form("v_-"+str(i+1)))
+
+    # Final recursive replacements
+    def rfx(tree_node):
+        if tree_node.name[:3] == "d_c":
+            return tree_form("v_" + str(int(tree_node.name[3:])+100))
+        tree_node.children = [rfx(child) for child in tree_node.children]
+        return tree_node
+
+    tree_node = rfx(tree_node)
+    return tree_node

mathai/printeq.py

@@ -1,34 +1,34 @@
-from .base import *
-from .simplify import solve
-import copy
-from fractions import Fraction
-def abstractexpr(eq):
-    if eq.name == "f_pow" and frac(eq.children[1])==Fraction(1,2):
-        eq = eq.children[0].fx("sqrt")
-    if eq.name == "f_pow" and frac(eq.children[1])==Fraction(-1,2):
-        eq = eq.children[0].fx("sqrt")**-1
-    if eq.name in ["f_mul", "f_pow"]:
-        
-        lst = factor_generation(eq)
-        deno = [item.children[0]**int(item.children[1].name[3:]) for item in lst if item.name == "f_pow" and item.children[1].name[:3] == "d_-"]
-        if eq.name == "f_mul" and any(item.name[:2] == "d_" and int(item.name[2:]) < 0 for item in lst):
-            return solve(-eq).fx("neg")
-        if deno != []:
-            
-            num = [item for item in lst if item.name != "f_pow" or item.children[1].name[:3] != "d_-"]
-            if num == []:
-                num = [tree_form("d_1")]
-            return TreeNode("f_div", [solve(product(num)), solve(product(deno))])
-    
-    
-    return TreeNode(eq.name, [abstractexpr(child) for child in eq.children])
-
-def printeq_str(eq):
-    return str(dowhile(copy.deepcopy(eq), abstractexpr))
-
-def printeq(eq):
-    print(printeq_str(eq))
-
-def printeq_log(lst):
-    for item in lst:
-        print("  "*item[0] + item[1])
+from .base import *
+from .simplify import solve
+import copy
+from fractions import Fraction
+def abstractexpr(eq):
+    if eq.name == "f_pow" and frac(eq.children[1])==Fraction(1,2):
+        eq = eq.children[0].fx("sqrt")
+    if eq.name == "f_pow" and frac(eq.children[1])==Fraction(-1,2):
+        eq = eq.children[0].fx("sqrt")**-1
+    if eq.name in ["f_mul", "f_pow"]:
+        
+        lst = factor_generation(eq)
+        deno = [item.children[0]**int(item.children[1].name[3:]) for item in lst if item.name == "f_pow" and item.children[1].name[:3] == "d_-"]
+        if eq.name == "f_mul" and any(item.name[:2] == "d_" and int(item.name[2:]) < 0 for item in lst):
+            return solve(-eq).fx("neg")
+        if deno != []:
+            
+            num = [item for item in lst if item.name != "f_pow" or item.children[1].name[:3] != "d_-"]
+            if num == []:
+                num = [tree_form("d_1")]
+            return TreeNode("f_div", [solve(product(num)), solve(product(deno))])
+    
+    
+    return TreeNode(eq.name, [abstractexpr(child) for child in eq.children])
+
+def printeq_str(eq):
+    return str(dowhile(copy.deepcopy(eq), abstractexpr))
+
+def printeq(eq):
+    print(printeq_str(eq))
+
+def printeq_log(lst):
+    for item in lst:
+        print("  "*item[0] + item[1])

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