mathai 2.4.6__tar.gz → 2.4.8__tar.gz

{mathai-2.4.6 → mathai-2.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.4.6
+Version: 2.4.8
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7

{mathai-2.4.6 → mathai-2.4.8}/mathai/__init__.py

@@ -20,7 +20,7 @@ from .linear import linear_solve
 
 from .test import test
 
-from .decision import god
+from .decision import god, god2
 
 from .expand import expand
 

mathai-2.4.8/mathai/benchmark.py

@@ -0,0 +1,195 @@
+import copy
+from pathlib import Path
+
+from .simplify import simplify
+from .expand import expand
+from .parser import parse
+from .fraction import fraction
+from .apart import apart
+from .integrate import (
+    integrate_formula,
+    integrate_trig_formula,
+    integrate_fraction,
+    integrate_subs_main as integrate_subs,
+    solve_integrate as integrate_clean,
+)
+from .factor import factor2
+from .trig import trig0, trig1, trig4, trig6
+from .univariate_inequality import simple_wavycurvy, absolute
+from .limit import limit1
+from .logic import logic0
+from .base import *
+
+
+fx_list = [
+    lambda x: dowhile(x, absolute),
+    logic0,
+    limit1,
+    simple_wavycurvy,
+    simplify,
+    expand,
+    fraction,
+    integrate_formula,
+    integrate_subs,
+    integrate_trig_formula,
+    integrate_clean,
+    apart,
+    trig0,
+    trig1,
+    trig4,
+    integrate_fraction,
+    factor2,
+    trig6,
+]
+
+name_list = """
+absolute logic0 limit1 simple_wavycurvy simplify expand fraction
+integrate_formula integrate_subs integrate_trig_formula
+integrate_clean apart trig0 trig1 trig4 integrate_fraction factor2 trig6
+""".split()
+
+# O(1) name -> function lookup
+FUNCS = dict(zip(name_list, fx_list))
+
+
+# ---------------------------------------------------------------------------
+# Benchmark
+# ---------------------------------------------------------------------------
+
+
+def benchmark(s="ncert_data"):
+    data_path = Path(__file__).parent / f"{s}.txt"
+    output_path = Path(__file__).parent / f"{s}_optimized.txt"
+
+    optimized_lines = []
+
+    with open(data_path, "r", encoding="utf-8") as file:
+        for count, line in enumerate(file, 1):
+            parts = line.split()
+
+            if not parts:
+                continue
+
+            expr_str, *function_names = parts
+            eq = simplify(parse(expr_str))
+            effective_steps = [expr_str]
+
+            for func_name in function_names:
+                func = FUNCS[func_name]
+                prev_eq = copy.deepcopy(eq)
+                eq = func(eq)
+
+                if eq != prev_eq:
+                    effective_steps.append(func_name)
+
+            print(f"{count}. {expr_str} => {eq}")
+            optimized_lines.append(" ".join(effective_steps))
+
+    with open(output_path, "w", encoding="utf-8") as file:
+        file.write("\n".join(optimized_lines) + "\n")
+
+    print(f"\nOptimized dataset successfully written to: {output_path}")
+
+
+# ---------------------------------------------------------------------------
+# Strategy tree
+# ---------------------------------------------------------------------------
+
+
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.children = {}  # Dictionary for O(1) child lookup
+
+    def add_child(self, value):
+        if value not in self.children:
+            self.children[value] = Node(value)
+        return self.children[value]
+
+    def execute(self, equation, sequence=None, terminal_condition=None):
+        if sequence is None:
+            sequence = []
+
+        if self.value != "ROOT":
+            func = FUNCS[self.value]
+
+            # Track previous state to detect and prune no-ops
+            prev_eq = copy.deepcopy(equation)
+            equation = func(equation)
+
+            # PRUNING: if the function didn't change the equation, halt this branch
+            if equation == prev_eq:
+                return []
+
+            sequence = sequence + [self.value]
+
+            # Check terminal condition after applying the function
+            if terminal_condition is not None and terminal_condition(equation):
+                return [(equation, sequence)]
+
+        if not self.children:
+            return [(equation, sequence)]
+
+        results = []
+        for child in self.children.values():
+            results.extend(
+                child.execute(copy.deepcopy(equation), sequence, terminal_condition)
+            )
+
+        return results
+
+
+def strategy_tree(sequences):
+    root = Node("ROOT")
+
+    for sequence in sequences:
+        node = root
+
+        for function_name in sequence:
+            node = node.add_child(function_name)
+
+    return root
+
+
+def load_sequences(s="ncert_data"):
+    data_path = Path(__file__).parent / f"{s}.txt"
+    sequences = []
+
+    with open(data_path, "r", encoding="utf-8") as file:
+        for line in file:
+            parts = line.split()
+
+            if parts:
+                sequences.append(parts[1:])
+
+    return sequences
+
+
+def print_tree(node, depth=0):
+    print("  " * depth + str(node.value))
+
+    for child in node.children.values():
+        print_tree(child, depth + 1)
+
+
+# ---------------------------------------------------------------------------
+# Serial Execution Entry Point
+# ---------------------------------------------------------------------------
+
+
+def execute_serial(tree, equation, terminal_condition=None):
+    """
+    Executes the strategy tree serially and returns at most one 
+    matching path as a list of tuples: [(equation, sequence)].
+    """
+    for child in tree.children.values():
+        try:
+            results = child.execute(copy.deepcopy(equation), [], terminal_condition)
+        except Exception:
+            continue
+
+        for eq, seq in results:
+            if terminal_condition is None or terminal_condition(eq):
+                return [(eq, seq)]
+
+    return []

{mathai-2.4.6 → mathai-2.4.8}/mathai/decision.py

@@ -15,6 +15,7 @@ from .factor import factor2, factor
 from .limit import limit1, limit5
 from .linear import linear_solve
 from .matrix import matrix_solve, matrix_formula
+from .benchmark import load_sequences, strategy_tree, execute_serial
 
 def vlist_2(eq):
     out = []
@@ -60,6 +61,22 @@ def solve_subs(q):
     if len(solution.keys()) == 0:
         return orig
     return operation("f_and", [item for item in lst if all(not contain(item, tree_form(key)) for key in solution.keys())] + [TreeNode("f_eq", [tree_form(key), item]) for key, item in solution.items()])
+def _no_integrate_left(eq):
+    return eq.name == "f_range" or eq.name == "s_true" or all(not contain2(eq, "f_"+item) for item in "eq integrate subs limit limitpinf limitninf".split(" "))
+
+
+def god2(string):
+    out = execute_serial(
+        strategy_tree(load_sequences("ncert_data")),
+        simplify(parse(string)),
+        _no_integrate_left,
+    )
+    if len(out) >= 1:
+        print(string)
+        print("=>", out[0][0])
+        print(["parse", "simplify"] + out[0][1])
+    return None
+
 def god(string, debug=True):
     if debug:
         print(f"? {string}")

{mathai-2.4.6 → mathai-2.4.8}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.4.6
+Version: 2.4.8
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7

{mathai-2.4.6 → mathai-2.4.8}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="2.4.6",
+    version="2.4.8",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",

mathai-2.4.6/mathai/benchmark.py

@@ -1,63 +0,0 @@
-import random
-import copy
-from pathlib import Path
-from .simplify import simplify
-from .expand import expand
-from .parser import parse
-from .fraction import fraction
-from .apart import apart
-from .integrate import integrate_formula, integrate_trig_formula, integrate_fraction
-from .integrate import integrate_subs_main as integrate_subs
-from .integrate import solve_integrate as integrate_clean
-from .factor import factor2
-from .trig import trig0, trig1, trig4, trig6
-from .univariate_inequality import simple_wavycurvy, absolute
-from .limit import limit1
-from .logic import logic0
-from .base import *
-
-fx_list = [lambda x: dowhile(x, absolute), logic0, limit1, simple_wavycurvy, simplify, expand, fraction, integrate_formula, integrate_subs, integrate_trig_formula, integrate_clean, apart, trig0, trig1, trig4, integrate_fraction, factor2, trig6]
-name_list = "absolute, logic0, limit1, simple_wavycurvy, simplify, expand, fraction, integrate_formula, integrate_subs, integrate_trig_formula, integrate_clean, apart, trig0, trig1, trig4, integrate_fraction, factor2, trig6".split(", ")
-
-def benchmark(s="ncert_data"):
-    data_path = Path(__file__).parent / f"{s}.txt"
-    output_path = Path(__file__).parent / f"{s}_optimized.txt"
-    
-    optimized_lines = []
-    
-    with open(data_path, "r", encoding="utf-8") as file:
-        content = file.read().strip().split("\n")
-        count = 0
-        for item in content:
-            count += 1
-            item = item.strip()
-            if not item:
-                continue
-            parts = item.split(" ")
-            expr_str = parts[0]
-            eq = simplify(parse(expr_str))
-            
-            effective_steps = [expr_str]
-            
-            for func_name in parts[1:]:
-                func_idx = name_list.index(func_name)
-                func = fx_list[func_idx]
-                
-                # Deepcopy to avoid in-place mutation reference traps
-                prev_eq = copy.deepcopy(eq)
-                eq = func(eq)
-                
-                # Check if the function changed the equation
-                if eq == prev_eq:
-                    pass
-                else:
-                    effective_steps.append(func_name)
-            
-            print(f"{count}. {expr_str} => {eq}")
-            optimized_lines.append(" ".join(effective_steps))
-            
-    # Write out the optimized lines without non-changing functions
-    with open(output_path, "w", encoding="utf-8") as outfile:
-        outfile.write("\n".join(optimized_lines) + "\n")
-        
-    print(f"\nOptimized dataset successfully written to: {output_path}")