mathai 2.4.8__tar.gz → 2.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.4.8
+Version: 2.5.0
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7
@@ -602,18 +602,24 @@ top_view_length : 80
 line_length : 80
 ```
 
-#### Example Demonstration 13 (formula applier)
+#### Example Demonstration 13 (formula compiler/applier)
 ```python
 from mathai import *
 formula = "a*x^2+b*x+c a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a))"
 formula += " [[a,1],[b,0],[b,1]] _ _ _ _"
 question = simplify(parse("sin(x)^2-4*sin(x)+4"))
-print(formula_applier(question, formula))
+print(formula_list_compiler(formula)(question))
+
+formula = "sin(x)^2+cos(x)^2 1"
+formula += " [] _ _ _ _"
+question = simplify(parse("sin(pi/3)^2+cos(pi/3)^2+1"))
+print(formula_list_compiler(formula)(question))
 ```
 
 #### Output
 ```
 (-2+sin(x))^2
+2
 ```
 
 ### Questions solved using god() function

{mathai-2.4.8 → mathai-2.5.0}/README.md

@@ -589,18 +589,24 @@ top_view_length : 80
 line_length : 80
 ```
 
-#### Example Demonstration 13 (formula applier)
+#### Example Demonstration 13 (formula compiler/applier)
 ```python
 from mathai import *
 formula = "a*x^2+b*x+c a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a))"
 formula += " [[a,1],[b,0],[b,1]] _ _ _ _"
 question = simplify(parse("sin(x)^2-4*sin(x)+4"))
-print(formula_applier(question, formula))
+print(formula_list_compiler(formula)(question))
+
+formula = "sin(x)^2+cos(x)^2 1"
+formula += " [] _ _ _ _"
+question = simplify(parse("sin(pi/3)^2+cos(pi/3)^2+1"))
+print(formula_list_compiler(formula)(question))
 ```
 
 #### Output
 ```
 (-2+sin(x))^2
+2
 ```
 
 ### Questions solved using god() function

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

@@ -7,7 +7,9 @@ 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
+from .square_root import solve_sqrt
+
+from .benchmark import benchmark, god2, benchmark_test
 
 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, god2
+from .decision import god
 
 from .expand import expand
 

{mathai-2.4.8 → mathai-2.5.0}/mathai/benchmark.py

@@ -1,5 +1,6 @@
 import copy
 from pathlib import Path
+import concurrent.futures
 
 from .simplify import simplify
 from .expand import expand
@@ -20,9 +21,16 @@ from .limit import limit1
 from .logic import logic0
 from .base import *
 
+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(" "))
+
+# Top-level helper function for picklability in multiprocessing
+def run_absolute(x):
+    return dowhile(x, absolute)
+
 
 fx_list = [
-    lambda x: dowhile(x, absolute),
+    run_absolute,
     logic0,
     limit1,
     simple_wavycurvy,
@@ -52,45 +60,6 @@ integrate_clean apart trig0 trig1 trig4 integrate_fraction factor2 trig6
 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
 # ---------------------------------------------------------------------------
@@ -173,7 +142,7 @@ def print_tree(node, depth=0):
 
 
 # ---------------------------------------------------------------------------
-# Serial Execution Entry Point
+# Serial & Parallel Execution Entry Points
 # ---------------------------------------------------------------------------
 
 
@@ -193,3 +162,136 @@ def execute_serial(tree, equation, terminal_condition=None):
                 return [(eq, seq)]
 
     return []
+
+
+def _execute_child_worker(args):
+    """Worker helper function for parallel execution across cores."""
+    child, equation, terminal_condition = args
+    try:
+        return child.execute(copy.deepcopy(equation), [], terminal_condition)
+    except Exception:
+        return []
+
+
+def execute_parallel(tree, equation, terminal_condition=None):
+    """
+    Splits the strategy tree root node's children and distributes 
+    them across multiple CPU cores using ProcessPoolExecutor.
+    """
+    children = list(tree.children.values())
+    if not children:
+        return []
+
+    tasks = [(child, equation, terminal_condition) for child in children]
+
+    with concurrent.futures.ProcessPoolExecutor() as executor:
+        futures = [executor.submit(_execute_child_worker, task) for task in tasks]
+        
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                results = future.result()
+                for eq, seq in results:
+                    if terminal_condition is None or terminal_condition(eq):
+                        return [(eq, seq)]
+            except Exception:
+                continue
+
+    return []
+
+
+def god2(string, parallel=False):
+    tree = strategy_tree(load_sequences("ncert_data"))
+    if parallel:
+        out = execute_parallel(tree, simplify(parse(string)), _no_integrate_left)
+    else:
+        out = execute_serial(tree, simplify(parse(string)), _no_integrate_left)
+    if len(out) >= 1:
+        print(string)
+        print("=>", out[0][0])
+        print(["parse", "simplify"] + out[0][1])
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Benchmark Test (Pure Execution, No Writing, No Strategy Trees)
+# ---------------------------------------------------------------------------
+
+
+def benchmark_test(s="ncert_data"):
+    data_path = Path(__file__).parent / f"{s}.txt"
+
+    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))
+
+            for func_name in function_names:
+                func = FUNCS[func_name]
+                prev_eq = copy.deepcopy(eq)
+                eq = func(eq)
+
+            print(f"{count}. {expr_str} => {eq}")
+
+    print(f"\nBenchmark test execution completed for: {s}.txt")
+
+
+# ---------------------------------------------------------------------------
+# 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 = []
+    
+    # Initialize an empty strategy tree
+    tree = Node("ROOT")
+
+    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_parsed = simplify(parse(expr_str))
+
+            # Try solving with the strategy tree built so far
+            out = execute_serial(tree, eq_parsed, _no_integrate_left)
+
+            if len(out) >= 1:
+                # Solved successfully by the strategy tree: DO NOT update tree, exclude from optimized file
+                print(f"{count}.", expr_str, "=>", out[0][0])
+                continue
+
+            # Strategy tree failed: fall back to manual function sequence
+            eq = eq_parsed
+            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)
+
+            # Update the strategy tree ONLY because it failed
+            current_node = tree
+            for func_name in effective_steps[1:]:
+                current_node = current_node.add_child(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}")

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

@@ -15,7 +15,6 @@ 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 = []
@@ -61,21 +60,6 @@ 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:

{mathai-2.4.8 → mathai-2.5.0}/mathai/ncert_data.txt

@@ -1,5 +1,7 @@
-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
+(x+1)*(x-1)=x^2-1 expand simplify logic0
+(a+b)^2=a^2+b^2+2*a*b expand simplify logic0
+1+1=2 logic0
+sin(x)^2+cos(x)^2=1 trig1 simplify 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
@@ -62,3 +64,5 @@ 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
+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

mathai-2.5.0/mathai/ncert_data_optimized.txt

@@ -0,0 +1,22 @@
+(x+1)*(x-1)=x^2-1 expand simplify logic0
+1+1=2 logic0
+sin(x)^2+cos(x)^2=1 trig1 logic0
+(1/(1-4*i)-2/(1+i))*((3-4*i)/(5+i))
+limit((1-cos(x))/x,x) limit1
+4*x+3<6*x+7 simple_wavycurvy
+integrate(x/((x+1)*(x+2)),x) 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(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(x^2*(1-1/x^2),x) expand simplify integrate_formula
+integrate(sec(x)^2/cosec(x)^2,x) trig0 simplify integrate_trig_formula integrate_formula trig1
+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((4*x+2)*sqrt(x^2+x+1),x) integrate_subs integrate_formula integrate_clean
+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

mathai-2.5.0/mathai/square_root.py

@@ -0,0 +1,617 @@
+"""Exact arithmetic with (nested) square roots.
+
+G  : an exact value  const + sum(coef * sqrt(key))  where coef is a Fraction
+     and key is a Fraction or, for nested radicals, another G.
+F  : a number that is either an exact Fraction or a symbolic TreeNode.
+"""
+import itertools
+import math
+from fractions import Fraction
+
+from .base import *
+from .simplify import simplify
+
+MAX_INT_POWER = 64          # largest |integer exponent| expanded exactly
+MAX_CONJUGATE_RADICALS = 8  # rationalising uses 2**n conjugates; cap n
+
+
+class NotRadical(Exception):
+    """The tree is not  const + sum(rational * sqrt(...))."""
+
+
+# --------------------------------------------------------------------------
+# small number helpers
+# --------------------------------------------------------------------------
+def frac_to_tree_2(eq):
+    if isinstance(eq, int):
+        eq = Fraction(eq)
+    if eq.numerator == 0:
+        return tree_form("d_0")
+    if eq.denominator == 1:
+        return tree_form(f"d_{eq.numerator}")
+    return TreeNode("f_div", [tree_form(f"d_{eq.numerator}"),
+                              tree_form(f"d_{eq.denominator}")])
+
+
+def perfect_sqrt(n):
+    """Exact rational square root of n, or None."""
+    n = Fraction(n)
+    if n < 0:
+        return None
+    p, q = math.isqrt(n.numerator), math.isqrt(n.denominator)
+    if p * p == n.numerator and q * q == n.denominator:
+        return Fraction(p, q)
+    return None
+
+
+def simplify_sqrt(a):
+    """sqrt(a) = b * sqrt(c) with c squarefree (integer-valued Fraction)."""
+    a = Fraction(a)
+    if a <= 0:
+        return Fraction(1), a
+    p, q = a.numerator, a.denominator
+    c, b = p * q, 1            # sqrt(p/q) = sqrt(p*q) / q
+    while c % 4 == 0:
+        c //= 4
+        b *= 2
+    i = 3
+    while i * i <= c:
+        while c % (i * i) == 0:
+            c //= i * i
+            b *= i
+        i += 2
+    return Fraction(b, q), Fraction(c)
+
+
+def coeff(eq):
+    """Split eq into (rational k, rest) with eq = k * rest; rest is None if eq is rational."""
+    out = frac(eq)
+    if out is not None:
+        return out, None
+    k, rest = Fraction(1), []
+    for factor in factor_generation(eq):
+        v = frac(factor)
+        if v is None:
+            rest.append(factor)
+        else:
+            k *= v
+    return k, product(rest)
+
+
+def _coerce(x):
+    if isinstance(x, G):
+        return x
+    if isinstance(x, (int, Fraction)) and not isinstance(x, bool):
+        return G({}, Fraction(x))
+    raise TypeError(f"cannot use {type(x).__name__} as a G")
+
+
+# --------------------------------------------------------------------------
+# tree rewriting helpers
+# --------------------------------------------------------------------------
+def helper_2_h(eq):
+    if eq.name == "f_sqrt":
+        return eq.children[0] ** (tree_form("d_2") ** tree_form("d_-1"))
+    if eq.name == "f_div":
+        return eq.children[0] * eq.children[1] ** tree_form("d_-1")
+    return eq
+
+
+def helper_3_h(eq):
+    if eq.name == "f_sub":
+        return eq.children[0] - eq.children[1]
+    if eq.name == "f_neg":
+        return -eq.children[0]
+    return eq
+
+
+def helper_2(eq):
+    return transform_dfs(eq, helper_2_h)
+
+
+def helper_3(eq):
+    return transform_dfs(eq, helper_3_h)
+
+
+def _tree_eq(self):
+    return TreeNode(self.name, [child.eq() for child in self.children])
+
+
+TreeNode.eq = _tree_eq
+
+
+# --------------------------------------------------------------------------
+# G : const + sum(coef * sqrt(key))
+# --------------------------------------------------------------------------
+class G:
+    def __init__(self, dic=None, const=Fraction(0)):
+        self.const = Fraction(const)
+        self.dic = {}
+        if dic is None:
+            return
+        if isinstance(dic, TreeNode):
+            self._from_tree(dic)
+            return
+        for key, item in dic.items():
+            if isinstance(key, int):
+                key = Fraction(key)
+            self.dic[key] = self.dic.get(key, Fraction(0)) + Fraction(item)
+
+    def _from_tree(self, tree):
+        value = frac(tree)
+        if value is not None:
+            self.const += value
+            return
+        terms = tree.children if tree.name == "f_add" else [tree]
+        for term in terms:
+            k, rest = coeff(helper_2(term))
+            if rest is None:
+                self.const += k
+                continue
+            if rest.name != "f_pow" or frac(rest.children[1]) != Fraction(1, 2):
+                raise NotRadical(str(term))
+            radicand = G(rest.children[0])
+            if not radicand.dic and radicand.const < 0:
+                raise NotRadical("negative radicand")
+            key = radicand if radicand.dic else radicand.const
+            self.dic[key] = self.dic.get(key, Fraction(0)) + k
+        self.simplify()
+
+    # ---- normal form -----------------------------------------------------
+    def copy(self):
+        return G(self.dic, self.const)
+
+    def is_zero(self):
+        return not self.dic and self.const == 0
+
+    def simplify(self):
+        """In place: pull squares out of radicands, merge equal radicals,
+        drop zero terms, move sqrt(1) terms into the constant."""
+        dic, const = {}, self.const
+        for key, coef in self.dic.items():
+            if isinstance(key, G):
+                key = key.copy().simplify()
+                if not key.dic:
+                    key = key.const
+            if isinstance(key, Fraction):
+                b, key = simplify_sqrt(key)
+                coef = coef * b
+                if key == 1:
+                    const += coef
+                    continue
+            dic[key] = dic.get(key, Fraction(0)) + coef
+        self.dic = {k: v for k, v in dic.items()
+                    if v != 0 and not (isinstance(k, Fraction) and k == 0)}
+        self.const = const
+        return self
+
+    # ---- arithmetic ------------------------------------------------------
+    def _terms(self):
+        return list(self.dic.items()) + [(Fraction(1), self.const)]
+
+    def __add__(self, other):
+        try:
+            other = _coerce(other)
+        except TypeError:
+            return NotImplemented
+        out = dict(self.dic)
+        for key, coef in other.dic.items():
+            out[key] = out.get(key, Fraction(0)) + coef
+        return G(out, self.const + other.const).simplify()
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return G({k: -v for k, v in self.dic.items()}, -self.const)
+
+    def __sub__(self, other):
+        try:
+            return self + (-_coerce(other))
+        except TypeError:
+            return NotImplemented
+
+    def __rsub__(self, other):
+        try:
+            return _coerce(other) + (-self)
+        except TypeError:
+            return NotImplemented
+
+    def __mul__(self, other):
+        try:
+            other = _coerce(other)
+        except TypeError:
+            return NotImplemented
+        out = {}
+        for a, ca in self._terms():
+            for b, cb in other._terms():
+                if isinstance(a, Fraction) and isinstance(b, Fraction):
+                    c = a * b
+                else:
+                    ga = G({}, a) if isinstance(a, Fraction) else a
+                    gb = G({}, b) if isinstance(b, Fraction) else b
+                    c = (ga * gb).simplify()
+                    if not c.dic:
+                        c = c.const
+                out[c] = out.get(c, Fraction(0)) + ca * cb
+        return G(out).simplify()
+
+    __rmul__ = __mul__
+
+    def __pow__(self, n):
+        """Integer powers; a negative power may return a TreeNode (see __truediv__)."""
+        if not isinstance(n, int):
+            return NotImplemented
+        if n < 0:
+            return G({}, 1) / (self ** -n)
+        result, base = G({}, 1), self.copy()
+        while n:
+            if n & 1:
+                result = result * base
+            n >>= 1
+            if n:
+                base = base * base
+        return result
+
+    def __truediv__(self, other):
+        """Returns a G, or a TreeNode when the quotient can't be rationalised."""
+        try:
+            other = _coerce(other)
+        except TypeError:
+            return NotImplemented
+        num, den = nested_radical(self), nested_radical(other)
+        if den.is_zero():
+            raise ZeroDivisionError("division by zero in G")
+        if num.is_zero():
+            return num
+        fallback = TreeNode("f_div", [num.eq(), den.eq()])
+        if any(isinstance(k, G) for k in den.dic):
+            return fallback
+        keys = list(den.dic)
+        if keys:
+            if len(keys) > MAX_CONJUGATE_RADICALS:
+                return fallback
+            conj_prod = G({}, 1)
+            for signs in itertools.product((1, -1), repeat=len(keys)):
+                if all(s == 1 for s in signs):
+                    continue          # that one is `den` itself
+                conj = G({k: den.dic[k] * s for k, s in zip(keys, signs)}, den.const)
+                conj_prod = conj_prod * conj
+            norm = nested_radical(conj_prod * den)
+            if norm.dic or norm.const == 0:   # radicals not independent -> give up
+                return fallback
+            ans = nested_radical(conj_prod * num)
+        else:
+            norm, ans = G({}, den.const), num
+        return G({k: v / norm.const for k, v in ans.dic.items()},
+                 ans.const / norm.const).simplify()
+
+    def __rtruediv__(self, other):
+        try:
+            return _coerce(other) / self
+        except TypeError:
+            return NotImplemented
+
+    # ---- comparison / display -------------------------------------------
+    def __eq__(self, other):
+        if isinstance(other, (int, Fraction)) and not isinstance(other, bool):
+            return not self.dic and self.const == other
+        if not isinstance(other, G):
+            return NotImplemented
+        return str_form(self.eq()) == str_form(other.eq())
+
+    def __hash__(self):
+        return hash(str_form(self.eq()))
+
+    def __repr__(self):
+        return str(self.eq())
+
+    def eq(self):
+        terms = []
+        for key, coef in self.dic.items():
+            if isinstance(key, Fraction):
+                root = frac_to_tree_2(key).fx("sqrt")
+            else:
+                root = key.eq().fx("sqrt")
+            if coef == 1:
+                terms.append(root)
+            elif coef != 0:
+                terms.append(frac_to_tree_2(coef) * root)
+        if self.const != 0:
+            terms.append(frac_to_tree_2(self.const))
+        return summation(terms)
+
+
+# --------------------------------------------------------------------------
+# denesting:  sqrt(a + b*sqrt(c)) = sqrt(x) +/- sqrt(y)
+# --------------------------------------------------------------------------
+def denest(g):
+    """(sqrt(g) as a G, True) if g denests, otherwise (g normalised, False)."""
+    g = nested_radical(g)
+    if len(g.dic) != 1:
+        return g, False
+    (c, b), = g.dic.items()
+    a = g.const
+    if isinstance(c, G) or c <= 0 or a <= 0:
+        return g, False
+    d = perfect_sqrt(a * a - b * b * c)
+    if d is None:
+        return g, False
+    x, y = (a + d) / 2, (a - d) / 2
+    sign = Fraction(1) if b > 0 else Fraction(-1)
+    return (G({x: Fraction(1)}) + G({y: sign})), True
+
+
+def nested_radical(g):
+    """Denest every nested radical of g that can be denested; returns a G."""
+    out, extra = {}, []
+    for key, coef in g.dic.items():
+        if isinstance(key, G):
+            val, ok = denest(key)
+            if ok:
+                extra.append(val * coef)
+                continue
+            key = val if val.dic else val.const
+        out[key] = out.get(key, Fraction(0)) + coef
+    result = G(out, g.const).simplify()
+    for e in extra:
+        result = result + e
+    return result
+
+
+# --------------------------------------------------------------------------
+# tree -> G evaluation
+# --------------------------------------------------------------------------
+def valid(eq):
+    if eq.name == "f_div" and contain2(eq.children[1], "f_sqrt"):
+        return False
+    if contain2(eq, "f_mul"):
+        return False
+    return all(valid(child) for child in eq.children)
+
+
+def _to_tree(x):
+    return x.eq() if isinstance(x, G) else x
+
+
+def _sqrt_of(inner):
+    if not isinstance(inner, G):
+        return TreeNode("f_sqrt", [inner])
+    inner = inner.copy().simplify()
+    if not inner.dic and inner.const < 0:
+        return TreeNode("f_sqrt", [inner.eq()])
+    return G({inner: Fraction(1)}).simplify()
+
+
+def _divide(a, b):
+    if isinstance(a, G) and isinstance(b, G):
+        if b.is_zero():
+            return TreeNode("f_div", [a.eq(), b.eq()])
+        return a / b
+    return TreeNode("f_div", [_to_tree(a), _to_tree(b)])
+
+
+def calc(eq):
+    """Evaluate a tree to a G where possible; unknown parts stay TreeNodes.
+    Never returns None."""
+    if not isinstance(eq, TreeNode):
+        return eq
+    value = frac(eq)
+    if value is not None:
+        return G({}, value)
+    if valid(eq):
+        try:
+            return G(eq)
+        except NotRadical:
+            pass
+    if not eq.children:
+        return eq
+
+    name = eq.name
+    parts = [calc(child) for child in eq.children]
+
+    if name in ("f_add", "f_mul"):
+        is_add = name == "f_add"
+        acc = G({}, 0 if is_add else 1)
+        rest = []
+        for p in parts:
+            if isinstance(p, G):
+                acc = acc + p if is_add else acc * p
+            else:
+                rest.append(p)
+        if not rest:
+            return acc
+        if is_add:
+            return summation(rest + ([] if acc.is_zero() else [acc.eq()]))
+        if acc.is_zero():
+            return acc
+        return product(rest + ([] if acc == 1 else [acc.eq()]))
+
+    if name == "f_sqrt" and len(parts) == 1:
+        return _sqrt_of(parts[0])
+
+    if name == "f_div" and len(parts) == 2:
+        return _divide(parts[0], parts[1])
+
+    if name == "f_pow" and len(parts) == 2 and isinstance(parts[0], G):
+        base, e = parts[0], frac(eq.children[1])
+        if e == Fraction(1, 2):
+            return _sqrt_of(base)
+        if e is not None and e.denominator == 1 and abs(e) <= MAX_INT_POWER:
+            n = int(e)
+            if n > 0 or (n == 0 and not base.is_zero()):
+                return base ** n
+            if n < 0 and not base.is_zero():
+                return _divide(G({}, 1), base ** -n)
+
+    return TreeNode(name, [_to_tree(p) for p in parts])
+
+
+def solve_sqrt_h(eq):
+    x = calc(flatten_tree(helper_3(eq)))
+    if isinstance(x, G):
+        x = nested_radical(x).eq()
+    return flatten_tree(x)
+
+
+def solve_sqrt(eq):
+    return dowhile(eq, lambda x: simplify(solve_sqrt_h(x), False))
+
+
+def print_raw(eq):
+    print(string_equation(str_form(eq)))
+
+
+def frac_2(eq):
+    return frac(helper_2(eq))
+
+
+def simp(eq):
+    if isinstance(eq, F):
+        eq = eq.value
+    if isinstance(eq, TreeNode):
+        out = solve_sqrt(eq)
+        if out is not None:
+            eq = out
+        value = frac_2(eq)
+        return eq if value is None else value
+    return eq
+
+
+# --------------------------------------------------------------------------
+# F : exact Fraction or symbolic TreeNode
+# --------------------------------------------------------------------------
+def get_value(x):
+    if isinstance(x, F):
+        return x.value
+    if isinstance(x, int):
+        return Fraction(x)
+    return x
+
+
+def promote_obj(x):
+    if isinstance(x, F):
+        x = x.value
+    if isinstance(x, TreeNode):
+        return x
+    if isinstance(x, (int, Fraction)):
+        return frac_to_tree_2(Fraction(x))
+    raise TypeError(f"cannot promote {type(x).__name__}")
+
+
+def _is_operand(x):
+    return isinstance(x, (int, Fraction, TreeNode, F)) and not isinstance(x, bool)
+
+
+def compare(a, b):
+    """-1 / 0 / 1, or None when the two can't be compared numerically."""
+    a, b = get_value(a), get_value(b)
+    if isinstance(a, Fraction) and isinstance(b, Fraction):
+        return (a > b) - (a < b)
+    if isinstance(a, TreeNode) and isinstance(b, TreeNode) and str_form(a) == str_form(b):
+        return 0
+    vals = []
+    for item in (a, b):
+        if isinstance(item, TreeNode):
+            try:
+                item = compute(helper_2(item))
+            except OverflowError:
+                item = None
+        vals.append(item)
+    if any(v is None for v in vals):
+        return None
+    try:
+        x, y = float(vals[0]), float(vals[1])
+    except OverflowError:
+        return None
+    if math.isclose(x, y, rel_tol=1e-12, abs_tol=1e-12):
+        return 0
+    return 1 if x > y else -1
+
+
+class F:
+    def __init__(self, value=0):
+        if isinstance(value, F):
+            value = value.value
+        elif isinstance(value, int):
+            value = Fraction(value)
+        self.value = value
+        if isinstance(self.value, TreeNode):
+            self.value = simp(self.value)
+
+    def promote(self, other, op):
+        return F(TreeNode(op, [promote_obj(self), promote_obj(other)]))
+
+    def fx(self, name):
+        return F(TreeNode("f_" + name, [promote_obj(self)]))
+
+    def _binary(self, other, op, exact, reverse=False, force_symbolic=None):
+        if not _is_operand(other):
+            return NotImplemented
+        a, b = (F(other), self) if reverse else (self, F(other))
+        x, y = get_value(a), get_value(b)
+        if (isinstance(x, TreeNode) or isinstance(y, TreeNode)
+                or (force_symbolic is not None and force_symbolic(x, y))):
+            return a.promote(b, op)
+        return F(exact(x, y))
+
+    def __add__(self, o):     return self._binary(o, "f_add", lambda x, y: x + y)
+    def __radd__(self, o):    return self._binary(o, "f_add", lambda x, y: x + y, True)
+    def __sub__(self, o):     return self._binary(o, "f_sub", lambda x, y: x - y)
+    def __rsub__(self, o):    return self._binary(o, "f_sub", lambda x, y: x - y, True)
+    def __mul__(self, o):     return self._binary(o, "f_mul", lambda x, y: x * y)
+    def __rmul__(self, o):    return self._binary(o, "f_mul", lambda x, y: x * y, True)
+    def __truediv__(self, o): return self._binary(o, "f_div", lambda x, y: x / y)
+    def __rtruediv__(self, o): return self._binary(o, "f_div", lambda x, y: x / y, True)
+
+    # a non-integer exponent stays symbolic so the result stays exact
+    @staticmethod
+    def _fractional_exp(x, y):
+        return isinstance(y, Fraction) and y.denominator != 1
+
+    def __pow__(self, o):
+        return self._binary(o, "f_pow", lambda x, y: x ** y,
+                            force_symbolic=F._fractional_exp)
+
+    def __rpow__(self, o):
+        return self._binary(o, "f_pow", lambda x, y: x ** y, True,
+                            force_symbolic=F._fractional_exp)
+
+    def __neg__(self):
+        if isinstance(self.value, TreeNode):
+            return F(TreeNode("f_neg", [promote_obj(self)]))
+        return F(-self.value)
+
+    def __hash__(self):
+        v = get_value(self)
+        if isinstance(v, Fraction):
+            return hash(v)
+        return hash(str_form(v))
+
+    def __lt__(self, o):
+        return _is_operand(o) and compare(self, o) == -1
+
+    def __le__(self, o):
+        return _is_operand(o) and compare(self, o) in (-1, 0)
+
+    def __gt__(self, o):
+        return _is_operand(o) and compare(self, o) == 1
+
+    def __ge__(self, o):
+        return _is_operand(o) and compare(self, o) in (1, 0)
+
+    def __eq__(self, o):
+        if not _is_operand(o):
+            return NotImplemented
+        return compare(self, o) == 0
+
+    def __float__(self):
+        value = get_value(self)
+        if isinstance(value, TreeNode):
+            out = compute(helper_2(value))
+            if out is None:
+                raise ValueError("expression has no numeric value")
+            return float(out)
+        return float(value)
+
+    def __repr__(self):
+        return str(self.value)

{mathai-2.4.8 → mathai-2.5.0}/mathai/univariate_inequality.py

@@ -10,6 +10,7 @@ import copy
 from .diff import diff
 from .logic import logic0
 from .tool import poly, poly_simplify
+from .square_root import solve_sqrt
 
 def intersection2(domain, lst):
     domain = copy.deepcopy(domain)
@@ -606,6 +607,7 @@ def simple_wavycurvy(eq, mode=False):
     eq = factor2(eq)
     eq = simplify(eq, True, True)
     eq = wavycurvy(eq, mode)
+    eq = solve_sqrt(eq)
     if eq.name == "f_range":
         tmp = eq2range(eq).truth()
         if tmp == 1:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.4.8
+Version: 2.5.0
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7
@@ -602,18 +602,24 @@ top_view_length : 80
 line_length : 80
 ```
 
-#### Example Demonstration 13 (formula applier)
+#### Example Demonstration 13 (formula compiler/applier)
 ```python
 from mathai import *
 formula = "a*x^2+b*x+c a*(x-(-b+sqrt(b^2-4*a*c))/(2*a))*(x-(-b-sqrt(b^2-4*a*c))/(2*a))"
 formula += " [[a,1],[b,0],[b,1]] _ _ _ _"
 question = simplify(parse("sin(x)^2-4*sin(x)+4"))
-print(formula_applier(question, formula))
+print(formula_list_compiler(formula)(question))
+
+formula = "sin(x)^2+cos(x)^2 1"
+formula += " [] _ _ _ _"
+question = simplify(parse("sin(pi/3)^2+cos(pi/3)^2+1"))
+print(formula_list_compiler(formula)(question))
 ```
 
 #### Output
 ```
 (-2+sin(x))^2
+2
 ```
 
 ### Questions solved using god() function

{mathai-2.4.8 → mathai-2.5.0}/mathai.egg-info/SOURCES.txt

@@ -24,12 +24,14 @@ mathai/matrix.py
 mathai/ml.py
 mathai/mlscalar.py
 mathai/ncert_data.txt
+mathai/ncert_data_optimized.txt
 mathai/ode.py
 mathai/parser.py
 mathai/pde.py
 mathai/printeq.py
 mathai/qm.py
 mathai/simplify.py
+mathai/square_root.py
 mathai/statistics.py
 mathai/test.py
 mathai/tool.py

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

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="2.4.8",
+    version="2.5.0",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",
@@ -11,7 +11,7 @@ setup(
     packages=find_packages(),
     include_package_data=True,
     package_data={
-        "mathai": ["ncert_data.txt"],
+        "mathai": ["ncert_data.txt", "ncert_data_optimized.txt"],
     },
     python_requires=">=3.7",
 )