mathai 2.4.5__tar.gz → 2.4.7__tar.gz

{mathai-2.4.5 → mathai-2.4.7}/PKG-INFO

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

{mathai-2.4.5 → mathai-2.4.7}/mathai/__init__.py

@@ -1,3 +1,5 @@
+from .benchmark import load_sequences, strategy_tree, execute_parallel
+
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 
@@ -7,7 +9,7 @@ from .qm import hydrogen_gse, helium_gse, power_rule
 
 from .graphics import draw_graphics_from_solution, solve_graphics, solve_graphics_string
 
-from .benchmark import benchmark_ncert
+from .benchmark import benchmark
 
 from .formula_compiler import formula_compiler
 from .formula_compiler import formula_list_compiler
@@ -20,7 +22,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.7/mathai/benchmark.py

@@ -0,0 +1,312 @@
+import atexit
+import copy
+import multiprocessing
+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)
+
+
+# ---------------------------------------------------------------------------
+# Parallel execution
+#
+# Design: nothing heavy is pickled per call.
+#   - Each worker builds the tree once, from the dataset name, at pool start.
+#   - Terminal conditions are looked up by name in TERMINAL_CONDITIONS, so no
+#     function object is ever sent to a worker.
+#   - Pools persist across calls, so spawn/import cost is paid once.
+#   - Per task, only (branch index, equation, condition name, generation)
+#     is sent.
+# ---------------------------------------------------------------------------
+
+# Register terminal conditions here. Workers re-import this module and find
+# them by name.
+TERMINAL_CONDITIONS = {
+    "no_integrate": lambda eq: not contain2(eq, "f_integrate"),
+}
+
+_TREES = {}  # data_name -> root Node (cached per process)
+_POOLS = {}  # (data_name, n_cores) -> (pool, generation counter)
+
+# Worker-process globals, set once by _init_worker
+_W_BRANCHES = None
+_W_GEN = None
+
+
+def _get_tree(data_name):
+    if data_name not in _TREES:
+        _TREES[data_name] = strategy_tree(load_sequences(data_name))
+    return _TREES[data_name]
+
+
+def _init_worker(data_name, gen):
+    global _W_BRANCHES, _W_GEN
+    _W_BRANCHES = list(_get_tree(data_name).children.values())
+    _W_GEN = gen
+
+
+def _worker(task):
+    idx, equation, cond_name, my_gen = task
+
+    # Stale task left over from a call that already finished: skip it.
+    if _W_GEN.value != my_gen:
+        return []
+
+    cond = TERMINAL_CONDITIONS[cond_name] if cond_name else None
+    try:
+        return _W_BRANCHES[idx].execute(equation, [], cond)
+    except Exception:
+        # A failing branch must not discard results from other branches.
+        return []
+
+
+def _first_match(results, cond):
+    for eq, seq in results:
+        if cond is None or cond(eq):
+            return [(eq, seq)]
+    return None
+
+
+def _execute_sequential(data_name, equation, cond_name):
+    cond = TERMINAL_CONDITIONS[cond_name] if cond_name else None
+
+    for child in _get_tree(data_name).children.values():
+        try:
+            results = child.execute(copy.deepcopy(equation), [], cond)
+        except Exception:
+            continue  # same semantics as the workers
+
+        match = _first_match(results, cond)
+        if match is not None:
+            return match
+
+    return []
+
+
+def _get_pool(data_name, n_cores):
+    key = (data_name, n_cores)
+
+    if key not in _POOLS:
+        gen = multiprocessing.Value("i", 0, lock=False)
+        pool = multiprocessing.Pool(
+            n_cores, initializer=_init_worker, initargs=(data_name, gen)
+        )
+        _POOLS[key] = (pool, gen)
+
+    return _POOLS[key]
+
+
+def shutdown_pools():
+    for pool, _ in _POOLS.values():
+        pool.terminate()
+        pool.join()
+    _POOLS.clear()
+
+
+atexit.register(shutdown_pools)
+
+
+def execute_parallel(data_name, equation, n_cores=None, condition_name=None):
+    """
+    Run the strategy tree for `data_name` against `equation` and return at
+    most one result as a one-item list [(equation, sequence)].
+
+    condition_name: key into TERMINAL_CONDITIONS, or None.
+
+    On Windows/macOS (spawn start method) callers using n_cores > 1 must be
+    guarded by ``if __name__ == "__main__":``.
+    """
+    n_branches = len(_get_tree(data_name).children)
+    if n_branches == 0:
+        return []
+
+    if n_cores is None:
+        n_cores = multiprocessing.cpu_count()
+    # Never more processes than branches, never fewer than one
+    n_cores = max(1, min(n_cores, n_branches))
+
+    if n_cores == 1:
+        return _execute_sequential(data_name, equation, condition_name)
+
+    cond = TERMINAL_CONDITIONS[condition_name] if condition_name else None
+    pool, gen = _get_pool(data_name, n_cores)
+
+    my_gen = gen.value + 1
+    gen.value = my_gen
+    tasks = [(i, equation, condition_name, my_gen) for i in range(n_branches)]
+
+    try:
+        for branch_results in pool.imap_unordered(_worker, tasks):
+            match = _first_match(branch_results, cond)
+            if match is not None:
+                return match
+        return []
+    finally:
+        gen.value = my_gen + 1  # cancels any still-queued tasks

{mathai-2.4.5 → mathai-2.4.7}/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_parallel
 
 def vlist_2(eq):
     out = []
@@ -60,6 +61,20 @@ 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 god2(string, core=1):
+    out = execute_parallel(
+        "ncert_data", simplify(parse(string)), core, "no_integrate"
+    )
+
+    if len(out) >= 1:
+        print(string)
+        print("=>", out[0][0])
+        print(["parse", "simplify"] + out[0][1])
+
+    return out
+
 def god(string, debug=True):
     if debug:
         print(f"? {string}")

{mathai-2.4.5 → mathai-2.4.7}/mathai/ncert_data.txt

@@ -1,3 +1,14 @@
+abs(3*x-5)+abs(8-x)=abs(3+2*x) absolute simplify simple_wavycurvy
+(sin(x)+cosec(x))^2+(cos(x)+sec(x))^2=7+tan(x)^2+cot(x)^2 trig0 fraction trig1 fraction simplify trig1 logic0
+(1/(1-4*i)-2/(1+i))*((3-4*i)/(5+i))
+limit((1-cos(x))/x,x) limit1
+limit(sin(4*x)/sin(2*x),x) limit1
+4*x+3<6*x+7 simple_wavycurvy
+integrate(x/((x+1)*(x+2)),x) apart integrate_formula
+integrate((x^2+1)/(x^2-5*x+6),x) factor2 expand integrate_formula factor2 apart integrate_formula
+integrate(sin(2*x+5)^2,x) trig1 integrate_formula
+integrate((1-cos(x))/(1+cos(x)),x) trig6 expand integrate_formula integrate_trig_formula simplify integrate_trig_formula integrate_formula
+integrate(sin(x)/(1+cos(x)),x) trig6 expand integrate_formula simplify integrate_trig_formula
 integrate(cos(2*x),x) integrate_formula
 integrate(3*x^2+4*x^3,x) integrate_formula
 integrate(1/x,x) integrate_formula
@@ -5,7 +16,7 @@ integrate((x^3-1)/x^2,x) expand simplify integrate_formula
 integrate(x^(2/3)+1,x) integrate_formula
 integrate(x^(3/2)+2*e^x-1/x,x) integrate_formula
 integrate(sin(x)+cos(x),x) integrate_formula
-integrate(cosec(x)*(cosec(x)+cot(x)),x) trig0 fraction integrate_formula expand integrate_formula simplify integrate_trig_formula
+integrate(cosec(x)*(cosec(x)+cot(x)),x) trig0 fraction expand integrate_formula simplify integrate_trig_formula
 integrate((1-sin(x))/cos(x)^2,x) expand integrate_formula integrate_trig_formula
 integrate(sin(2*x),x) integrate_formula
 integrate(cos(3*x),x) integrate_formula
@@ -22,24 +33,24 @@ integrate((x^3+3*x+4)/sqrt(x),x) expand simplify integrate_formula
 integrate((x^3-x^2+x-1)/(x-1),x) expand integrate_formula apart integrate_formula integrate_subs expand simplify integrate_formula integrate_clean
 integrate((1-x)*sqrt(x),x) expand simplify integrate_formula
 integrate(sqrt(x)*(3*x^2+2*x+3),x) expand simplify integrate_formula
-integrate(2*x-3*cos(x)+e^x,x) simplify integrate_formula
+integrate(2*x-3*cos(x)+e^x,x) integrate_formula
 integrate(2*x^2-3*sin(x)+5*sqrt(x),x) integrate_formula
-integrate(sec(x)*(sec(x)+tan(x)),x) expand trig0 simplify integrate_formula integrate_trig_formula integrate_formula
-integrate(sec(x)^2/cosec(x)^2,x) trig0 simplify integrate_trig_formula integrate_formula trig1 integrate_formula
-integrate((2-3*sin(x))/cos(x)^2,x) expand simplify integrate_trig_formula integrate_formula integrate_trig_formula integrate_formula
-integrate(sqrt(x)+1/sqrt(x),x) expand simplify integrate_formula
+integrate(sec(x)*(sec(x)+tan(x)),x) expand trig0 simplify integrate_formula integrate_trig_formula
+integrate(sec(x)^2/cosec(x)^2,x) trig0 simplify integrate_trig_formula integrate_formula trig1
+integrate((2-3*sin(x))/cos(x)^2,x) expand simplify integrate_formula integrate_trig_formula
+integrate(sqrt(x)+1/sqrt(x),x) integrate_formula
 integrate(sin(x)^3*cos(x)^2,x) trig1 integrate_formula
-integrate(sin(x)/sin(x+a),x) integrate_subs trig4 expand simplify integrate_formula integrate_trig_formula integrate_formula integrate_clean
+integrate(sin(x)/sin(x+a),x) integrate_subs expand simplify integrate_formula integrate_trig_formula integrate_clean
 integrate((e^(2*x)-1)/(e^(2*x)+1),x) integrate_subs integrate_formula expand simplify apart integrate_formula integrate_clean
 integrate((e^(2*x)-e^(-2*x))/(e^(2*x)+e^(-2*x)),x) integrate_subs integrate_formula fraction simplify apart integrate_formula integrate_fraction integrate_clean
 integrate(tan(2*x-3)^2,x) trig0 integrate_trig_formula integrate_formula
-integrate(sec(7-4*x)^2,x) trig0 simplify integrate_trig_formula integrate_formula
+integrate(sec(7-4*x)^2,x) trig0 simplify integrate_trig_formula
 integrate((4*x+2)*sqrt(x^2+x+1),x) integrate_subs integrate_formula integrate_clean
 integrate(1/(x-sqrt(x)),x) integrate_subs integrate_formula factor2 apart integrate_formula integrate_clean
 integrate(e^arctan(x)/(1+x^2),x) integrate_subs integrate_formula integrate_clean
 integrate(x/e^(x^2),x) integrate_subs integrate_formula integrate_clean
 integrate(e^(2*x+3),x) integrate_formula
-integrate(x/(9-4*x^2),x) factor2 integrate_formula simplify apart simplify integrate_formula
+integrate(x/(9-4*x^2),x) factor2 simplify integrate_formula apart integrate_formula
 integrate(x^2/(2+3*x^3)^3,x) integrate_subs integrate_formula integrate_clean
 integrate(x*sqrt(1+2*x^2),x) integrate_subs integrate_formula integrate_clean
 integrate(x*sqrt(x+2),x) integrate_subs integrate_formula expand simplify integrate_formula integrate_clean
@@ -47,7 +58,7 @@ integrate(sqrt(a*x+b),x) integrate_formula
 integrate(sin(a*x+b)*cos(a*x+b),x) trig1 integrate_formula
 integrate(sin(cos(x))*sin(x),x) integrate_subs integrate_formula integrate_clean
 integrate(2*x/(1+x^2),x) integrate_formula integrate_fraction
-integrate(log(x)^2/x,x) integrate_subs simplify integrate_formula simplify integrate_formula integrate_clean
+integrate(log(x)^2/x,x) integrate_subs integrate_formula integrate_clean
 integrate(sin(arctan(x))/(1+x^2),x) integrate_subs integrate_formula integrate_clean
 integrate(2*x*sin(x^2+1),x) integrate_formula integrate_subs integrate_formula integrate_clean
-integrate(sin(m*x),x) integrate_formula
+integrate(sin(m*x),x) integrate_formula

{mathai-2.4.5 → mathai-2.4.7}/mathai/univariate_inequality.py

@@ -603,13 +603,6 @@ def domain(eq):
     return out
 
 def simple_wavycurvy(eq, mode=False):
-    if vlist(eq) == [] and (contain2(eq, "f_floor") or contain2(eq, "f_ceil")):
-        return dowhile(eq, lambda x: logic0(nothing(x)))
-    fx = lambda x: dowhile(x, lambda y: logic0(fraction(simplify(y))))
-    eq = fx(eq)
-    if "sqrt" in str(eq):
-        eq = handle_sqrt(eq)
-        eq = fx(eq)
     eq = factor2(eq)
     eq = simplify(eq, True, True)
     eq = wavycurvy(eq, mode)

{mathai-2.4.5 → mathai-2.4.7}/mathai.egg-info/PKG-INFO

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

{mathai-2.4.5 → mathai-2.4.7}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="2.4.5",
+    version="2.4.7",
     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.5/mathai/benchmark.py

@@ -1,31 +0,0 @@
-import random
-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
-from pathlib import Path
-fx_list = [simplify, expand, fraction, integrate_formula, integrate_subs, integrate_trig_formula, integrate_clean, apart, trig0, trig1, trig4, integrate_fraction, factor2]
-name_list = "simplify, expand, fraction, integrate_formula, integrate_subs, integrate_trig_formula, integrate_clean, apart, trig0, trig1, trig4, integrate_fraction, factor2".split(", ")
-def benchmark_ncert():
-    # Locate ncert_data.txt in the same directory as this benchmark.py file
-    data_path = Path(__file__).parent / "ncert_data.txt"
-    
-    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(" ")
-            eq = simplify(parse(parts[0]))
-            for item2 in parts[1:]:
-                eq = fx_list[name_list.index(item2)](eq)
-            print(f"{count}. {parts[0]} => {eq}")