mathai 2.3.6__tar.gz → 2.3.8__tar.gz

{mathai-2.3.6 → mathai-2.3.8}/PKG-INFO

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

{mathai-2.3.6 → mathai-2.3.8}/mathai/__init__.py

@@ -15,7 +15,7 @@ from .linear import linear_solve
 
 from .test import test
 
-from .decision import god, trig7
+from .decision import god
 
 from .expand import expand
 
@@ -54,7 +54,7 @@ from .limit import limit1, limit2, limit0, limit3, limit4, solve_inf, limit5
 
 from .univariate_inequality import wavycurvy, absolute, domain, handle_sqrt, prepare, eq2range, range2eq2, simple_wavycurvy
 
-from .matrix import matrix_solve
+from .matrix import matrix_solve, matrix_formula
 
 from .base import *
 from .printeq import printeq_obj, print_raw

mathai-2.3.8/mathai/decision.py

@@ -0,0 +1,134 @@
+import math
+from .inverse import inverse, inverse2
+from .integrate import integrate_full, def_integrate_formula
+from .ode import diffsolve as ode_solve
+from .parser import parse
+from .simplify import simplify, log0
+from .base import *
+from .diff import diff, diff2
+from .trig import trig0, trig1, zu_simplify
+from .univariate_inequality import simple_wavycurvy, wavycurvy, prepare, absolute, handle_sqrt, eq2range, domain, Range
+from .fraction import fraction
+from .expand import expand
+from .logic import logic0, set_sub, truth_gen, solve_logically
+from .factor import factor2, factor
+from .limit import limit1, limit5
+from .linear import linear_solve
+from .matrix import matrix_solve, matrix_formula
+
+def vlist_2(eq):
+    out = []
+    if eq.name[2:] in "det adj dim".split(" ") and eq.children[0].name[:2] == "v_":
+        return [eq]
+    if eq.name[:2] == "v_":
+        return [eq]
+    for child in eq.children:
+        out += vlist_2(child)
+    return list(set(out))
+def convert_single_solution(eq):
+    if eq.name == "f_range":
+        out = eq2range(eq)
+        if out.r == [False] and len(out.p) == 1:
+            return TreeNode("f_eq", [out.variable - out.p[0], TreeNode("d_0")])
+    return eq
+def solve_subs(q):
+    solution = {}
+    orig = copy.deepcopy(q)
+    if q.name != "f_and":
+        q = TreeNode("f_and", [q])
+    lst = q.children
+    if not all(item.name == "f_eq" for item in lst):
+        return orig
+    q = simplify(q)
+    done = True
+    while done:
+        done = False
+        for i in range(len(q.children)):
+            item = q.children[i]
+            for key, item2 in solution.items():
+                item = replace(item, tree_form(key), item2)
+            item = fraction(expand(trig0(simplify(item))))
+            q.children[i] = item
+            vars_in_item = vlist_2(item)
+            if len(vars_in_item) == 1:
+                target_var = vars_in_item[0]
+                tmp = inverse(item.children[0], str_form(target_var))
+                if tmp is not None:
+                    solution[str_form(target_var)] = tmp
+                    done = True
+                    break
+    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 god(string):
+    print(f"? {string}")
+    print("thinking...")
+    eq = None
+    eq = parse(string)
+    log = [eq]
+    if "f_pdif" in str_form(eq):
+        eq = diff2(eq)
+    if "f_limit" in str_form(eq):
+        eq = limit1(limit5(eq))
+    if any(contain2(eq, "f_"+item) for item in "adj det list transpose".split(" ")):
+           eq = matrix_formula(eq)
+           print(eq)
+           eq = matrix_solve(eq)
+           print(eq)
+           eq = solve_subs(eq)
+           print(f"=> {eq}")
+           print()
+           return eq
+    elif all(not contain2(eq, "f_"+item) for item in "dif add mul abs pow dif integrate arcsin sin cos log limit eq lt le ge gt".split(" ")) and\
+       any(contain2(eq, "f_"+item) for item in "and or not imply equiv".split(" ")):
+        eq = solve_logically(truth_gen(simplify(set_sub(eq))))
+        print(f"=> {eq}")
+        print()
+        return eq
+    elif not (eq.name == "f_and" and len(vlist(eq)) > 1) and any(contain2(eq, "f_"+item) for item in "eq lt le ge gt".split(" ")) and all(not contain2(eq, "f_"+item) for item in "limit dif integrate".split(" ")):
+        lst = [simplify, log0, simplify, lambda x: dowhile(x, absolute), lambda x: dowhile(x, lambda y: simplify(expand(y))), lambda x: dowhile(x, lambda y: simplify(fraction(y))), logic0, simple_wavycurvy, simple_wavycurvy]
+        fx2 = lambda x: dowhile(x, lambda y: simplify(fraction(y)))
+        fx3 = lambda x: dowhile(x, trig1)
+        lst2 = [simplify, trig0, lambda x: dowhile(x, lambda y: fx2(fx3(y))), solve_subs, logic0]
+        sel = lst.copy()
+        if any(contain2(eq, "f_"+item) for item in "sin cos tan cosec sec cot".split(" ")) or\
+           len(vlist(eq)) > 1:
+            sel = lst2
+        for item in sel:
+            eq = item(eq)
+            if eq not in log:
+                log.append(eq)
+                print(eq)
+        # eq = trig7(eq)
+        print(f"=> {eq}")
+        print()
+        return eq
+    elif "f_dif" in str_form(eq) or "f_integrate" in str_form(eq):
+        if "f_dif" in str_form(eq) and "f_integrate" not in str_form(eq):
+            eq = simplify(ode_solve(simplify(eq)))
+            log.append(eq)
+        if "f_integrate" in str_form(eq):
+            eq = def_integrate_formula(eq)
+            eq = integrate_full(eq)
+            eq = limit5(eq)
+            eq = limit1(eq)
+        eq = simplify(expand(simplify(eq)))
+        print(f"=> {eq}")
+        print()
+        return eq
+    if any("f_"+item in str_form(eq) for item in "eq lt le ge gt".split(" ")):
+        eq = simple_wavycurvy(eq)
+        eq = transform_dfs(eq, convert_single_solution)
+        out = linear_solve(eq)
+        if out is not None:
+            eq = out
+        print(eq)
+        eq = solve_subs(eq)
+        out = linear_solve(eq)
+        if out is not None:
+            eq = out
+        eq = simple_wavycurvy(eq)
+    eq = simplify(expand(simplify(fraction(simplify(eq)))))
+    print(f"=> {eq}")
+    print()
+    return eq

{mathai-2.3.6 → mathai-2.3.8}/mathai/formula_applier.py

@@ -16,15 +16,16 @@ _W_NAMES = {
 _COMMUTATIVE = frozenset(("f_addw", "f_mulw", "f_hadamardw"))
 _ORDERED_ASSOC = frozenset(("f_wmulw",))
 _LABEL_PREFIXES = frozenset(("f_", "s_", "d_"))
-_SPECIAL_PATTERN = frozenset(("f_poly", "f_sum", "f_product", "f_hprod"))
+_SPECIAL_PATTERN = frozenset(("f_poly", "f_sum", "f_product", "f_hprod", "f_mprod"))
 _PATTERN_OPS = {"f_sum": "f_addw", "f_product": "f_mulw", "f_hprod": "f_hadamardw"}
+_ORDERED_PATTERN_OPS = {"f_mprod": "f_wmulw"}
 _AGG_NAMES = frozenset((
     "f_addw", "f_add", "f_mulw", "f_mul", "f_hadamardw", "f_hadamard",
-    "f_product", "f_sum", "f_hprod", "f_poly",
+    "f_product", "f_sum", "f_hprod", "f_mprod", "f_poly", "f_wmulw", "f_wmul",
 ))
 _EXTRACT_NAMES = frozenset((
     "f_add", "f_wadd", "f_waddw", "f_wmul", "f_wmulw",
-    "f_mul", "f_product", "f_sum", "f_hprod", "f_poly",
+    "f_mul", "f_product", "f_sum", "f_hprod", "f_mprod", "f_poly",
 ))
 _DE_W_NAMES = frozenset(("f_addw", "f_mulw", "f_waddw", "f_hadamardw", "f_wmulw"))
 
@@ -32,7 +33,7 @@ _DE_W_NAMES = frozenset(("f_addw", "f_mulw", "f_waddw", "f_hadamardw", "f_wmulw"
 def transform_dfs(node, fn, stable=None):
     if node is None:
         return None
-    if stable is not None and node in stable:
+    if stable is not None and id(node) in stable:
         return node
     children = node.children
     if children is None:
@@ -50,15 +51,17 @@ def transform_dfs(node, fn, stable=None):
     if out is not None and out is not cur and out == cur:
         out = cur
     if stable is not None and unchanged and out is cur:
-        stable[cur] = cur
+        stable[id(cur)] = cur  # holding the reference keeps the id valid
     return out
 
 
 def dowhile(x, fn):
     while True:
         y = fn(x)
-        if y is x or y == x or y is None:
-            return x if y is None else y
+        if y is None:
+            return x
+        if y is x or y == x:
+            return y
         x = y
 
 
@@ -68,8 +71,10 @@ def _fixpoint(eq, fn):
     stable = {}
     while True:
         new = transform_dfs(eq, fn, stable)
-        if new is eq or new == eq or new is None:
-            return eq if new is None else new
+        if new is None:
+            return eq
+        if new is eq or new == eq:
+            return new
         eq = new
 
 
@@ -111,6 +116,8 @@ def _collect_labels(node, acc):
         acc.add("f_mulw")
     elif node.name == "f_hprod":
         acc.add("f_hadamardw")
+    elif node.name == "f_mprod":
+        acc.add("f_wmulw")
     elif node.name == "f_poly":
         acc.add("f_mulw")
         acc.add("f_addw")
@@ -190,6 +197,17 @@ def _as_exprs(x):
     return [x]
 
 
+def _as_pairs(x):
+    """Like _as_exprs but keeps [expr, value] pairs intact (no flattening)."""
+    if x is None or not isinstance(x, list):
+        return []
+    if x and all(isinstance(p, list) for p in x):
+        return [p for p in x if len(p) == 2]
+    if len(x) == 2 and not any(isinstance(p, list) for p in x):
+        return [x]  # a single bare pair
+    return []
+
+
 def _subst(node, mapping):
     if node is None:
         return None
@@ -254,9 +272,9 @@ def _match_struct_bind_core(eq, f, binding, const_1_vars, ignore_set, resolved_i
             out = extract_polynomial_coefficients(eq_plain, item, degree)
             if out is not None:
                 out = out[::-1]
-                while out[0] == 0:
+                while len(out) != 0 and out[0] == 0:
                     out.pop(0)
-                if len(out) == degree:                    
+                if len(out) == degree:
                     local_binding = binding.copy()
                     for i in range(1, len(f.children)):
                         local_binding[f.children[i].name] = out[i - 1]
@@ -293,6 +311,37 @@ def _match_struct_bind_core(eq, f, binding, const_1_vars, ignore_set, resolved_i
                     local_binding[f.children[1 - index].name] = operation(op_name, non_const_term)
                 binding.update(local_binding)
                 return True
+    if fname in _ORDERED_PATTERN_OPS and len(f.children) >= 2:
+        op_name = _ORDERED_PATTERN_OPS[fname]
+        if eq.name == op_name and len(eq.children) >= len(f.children):
+            fc, ec = f.children, eq.children
+            n = len(fc)
+            m = len(ec)
+            if m < n:
+                return False
+
+            def search_ordered_pattern(i, j, b):
+                if i == n:
+                    return b if j == m else None
+                pat = fc[i]
+                free = (not pat.children) and pat.name in free_vars
+                remaining_pats = n - i - 1
+                max_len = (m - j - remaining_pats) if free else 1
+                for L in range(1, max_len + 1):
+                    seg = ec[j] if L == 1 else TreeNode(op_name, list(ec[j:j + L]))
+                    sb = b.copy()
+                    if _match_struct_bind_core(seg, pat, sb, const_1_vars,
+                                               ignore_set, resolved_ignore, free_vars):
+                        r = search_ordered_pattern(i + 1, j + L, sb)
+                        if r is not None:
+                            return r
+                return None
+
+            result = search_ordered_pattern(0, 0, binding)
+            if result is None:
+                return False
+            binding.update(result)
+            return True
     if fname.startswith("v_") and not f.children and fname in free_vars:
         f_str = str_form(f)
         if f_str in binding:
@@ -391,11 +440,13 @@ def _match_struct_bind(eq, f, binding, const_1_vars=None, ignore_set=None,
 
 
 class _Matcher:
-    def __init__(self, formula, formula_out, positive=None, negative=None, ignore_list=None, const_1=None, forbidden_list=None):
+    def __init__(self, formula, formula_out, positive=None, negative=None,
+                 ignore_list=None, const_1=None, forbidden_list=None):
         self.orig_formula = formula
         self.formula_out = formula_out
         self.formula_w = en_w_addmul(formula)
-        self.root_name = self.formula_w.name if self.formula_w else ""
+        has_formula = self.formula_w is not None
+        self.root_name = self.formula_w.name if has_formula else ""
         f_sum_vars = set()
         _extract_f_sum_vars(self.formula_w, f_sum_vars)
         self.free_vars = frozenset(f_sum_vars)
@@ -404,15 +455,15 @@ class _Matcher:
         self.ignore_list_exprs = _as_exprs(ignore_list)
         self.ignore_set = {get_name(item) for item in self.ignore_list_exprs}
         self.ignore_names = {item.name for item in self.ignore_list_exprs}
-        self.forbidden_list_exprs = _as_exprs(forbidden_list)
-        
-        names = set(vlist(self.formula_w)) - f_sum_vars if self.formula_w else set()
+        self.forbidden_pairs = _as_pairs(forbidden_list)  # FIX: keep pairs intact
+
+        names = (set(vlist(self.formula_w)) - f_sum_vars) if has_formula else set()
         self.vl = sorted(names, key=lambda n: (0 if n in self.ignore_set else 1, n))
         self.must_be_var = {n: (n in self.ignore_set and n not in f_sum_vars) for n in self.vl}
         self.const_1_vars = {get_name(item) for item in _as_exprs(const_1)}
         self.must_be_const = {n: (n in self.const_1_vars) for n in self.vl}
         self.root_is_free = (
-            not self.formula_w
+            not has_formula
             or (self.root_name.startswith("v_") and not self.formula_w.children)
             or self.root_name in _SPECIAL_PATTERN
         )
@@ -423,19 +474,15 @@ class _Matcher:
         self._same_count = [count_same_nodes(self.orig_formula, TreeNode(x)) for x in self.vl]
 
     def _is_forbidden(self, mapping):
-        if not self.forbidden_list_exprs:
-            return False
-        for forb_pair in self.forbidden_list_exprs:
-            if isinstance(forb_pair, list) and len(forb_pair) == 2:
-                expr_part, forb_val = forb_pair[0], forb_pair[1]
-                subbed_expr = _subst(expr_part, mapping)
-                subbed_val = _subst(forb_val, mapping)
-                if subbed_expr is None or subbed_val is None:
-                    return True
-                simp_expr = simplify(subbed_expr)
-                simp_val = simplify(subbed_val)
-                if simp_expr is None or simp_val is None or simp_expr == simp_val:
-                    return True
+        for expr_part, forb_val in self.forbidden_pairs:
+            subbed_expr = _subst(expr_part, mapping)
+            subbed_val = _subst(forb_val, mapping)
+            if subbed_expr is None or subbed_val is None:
+                return True
+            simp_expr = simplify(subbed_expr)
+            simp_val = simplify(subbed_val)
+            if simp_expr is None or simp_val is None or simp_expr == simp_val:
+                return True
         return False
 
     def conditions_hold(self, mapping):
@@ -486,11 +533,11 @@ class _Matcher:
             eq_cand_w = en_w_addmul(equation)
             binding = {}
             if not _match_struct_bind(eq_w, eq_cand_w, binding, self.const_1_vars,
-                                       self.ignore_names, assigned_mapping, self.free_vars):
+                                      self.ignore_names, assigned_mapping, self.free_vars):
                 return None
             full_mapping = dict(assigned_mapping)
             full_mapping.update({k: de_w_addmul(v) for k, v in binding.items()})
-            
+
             if self._is_forbidden(full_mapping):
                 return None
 
@@ -549,8 +596,10 @@ class _Matcher:
         return dfs({}, 0, 0, frozenset())
 
 
-def structure(equation, formula, formula_out, ignore_list=None, const_1=None, positive=None, negative=None, forbidden_list=None):
-    return _Matcher(formula, formula_out, positive, negative, ignore_list, const_1, forbidden_list)(equation)
+def structure(equation, formula, formula_out, ignore_list=None, const_1=None,
+              positive=None, negative=None, forbidden_list=None):
+    return _Matcher(formula, formula_out, positive, negative, ignore_list,
+                    const_1, forbidden_list)(equation)
 
 
 def convert_lst(eq):
@@ -594,16 +643,15 @@ def _compile_rule(s):
     if parsed_subs:
         for key, value in parsed_subs:
             subs.setdefault(key, [None]).append(value)
-    
+
     lst = [convert_string(x) for x in item[3:]]
     lst += [None] * (5 - len(lst))
     ignore_list, const_1, positive, negative, forbidden_list = lst[:5]
-    
+
     keys = tuple(subs)
     matchers = []
     for combination in itertools.product(*subs.values()):
         x, y, pos, neg, forb = a, b, positive, negative, forbidden_list
-        valid_comb = True
         for key, value in zip(keys, combination):
             if value is not None:
                 x = replace(x, key, value)
@@ -611,22 +659,17 @@ def _compile_rule(s):
                 pos = _replace_in(pos, key, value)
                 neg = _replace_in(neg, key, value)
                 forb = _replace_in(forb, key, value)
-        
-        if forbidden_list is not None:
-            comb_map = {k: v for k, v in zip(keys, combination) if v is not None}
-            for forb_pair in _as_exprs(forbidden_list):
-                if isinstance(forb_pair, list) and len(forb_pair) == 2:
-                    sub_expr = _subst(forb_pair[0], comb_map)
-                    sub_val = _subst(forb_pair[1], comb_map)
-                    if sub_expr is None or sub_val is None:
-                        valid_comb = False
-                        break
-                    simp_expr = simplify(sub_expr)
-                    simp_val = simplify(sub_val)
-                    if simp_expr is None or simp_val is None or simp_expr == simp_val:
-                        valid_comb = False
-                        break
-        
+
+        # FIX: check the already-substituted pairs; skip combinations that are
+        # forbidden outright (e.g. a pair that simplifies to identical sides)
+        valid_comb = True
+        for expr_part, forb_val in _as_pairs(forb):
+            se = simplify(expr_part)
+            sv = simplify(forb_val)
+            if se is None or sv is None or se == sv:
+                valid_comb = False
+                break
+
         if valid_comb:
             simp_x = simplify(x)
             simp_y = simplify(y)

{mathai-2.3.6 → mathai-2.3.8}/mathai/integrate.py

@@ -8,7 +8,7 @@ from .fraction import fraction
 from .simplify import simplify
 from .expand import expand
 from .base import *
-from .formula_applier import formula_list_applier
+from .formula_applier import formula_list_applier, formula_applier
 from .inverse import inverse
 from .tool import poly
 from fractions import Fraction
@@ -36,6 +36,8 @@ def subs_heuristic(eq, var):
         if eq.name == "f_pow" and frac(eq.children[1]) is not None and frac(eq.children[1]) == Fraction(1,2):
             if eq.children[0] == var:
                 output.append(str_form(eq))
+        if eq.name == "f_log":
+            output.append(str_form(eq))
         if eq.name in ["f_pow"] and var.name in str_form(eq):
             if eq.children[1].name[:2] != "v_":
                 output.append(str_form(eq))
@@ -66,20 +68,22 @@ def subs_heuristic(eq, var):
     tmp = list(set([simplify(tree_form(x)) for x in output]))
     tmp = sorted(tmp, key=lambda x: len(str_form(x)))
     poly_term = None
-    
+    poly_size = -1
     fx = is_integrate_subs
     output = []
     if set(all_branch(eq)) <= set("f_add f_mul f_pow".split(" ")):
         for item in tmp:
             if fx(item).name == "s_true":
-                poly_term = item
+                if len(item) > poly_size:
+                    poly_term = item
+                    poly_size = len(item)
             else:
                 output.append(item)
     p = None
     if poly_term is None:
         p = tmp
     else:
-        p = output+[poly_term]
+        p = [poly_term]+output
     last = list(set(last))
     if len(p)>3:
         p = p[:3]
@@ -176,12 +180,14 @@ def integrate_subs(equation, term, v1, v2, extra):
     equation = simplify(equation)
     eq = equation
     termeq = term
-    t = inverse(copy.deepcopy(termeq), v1)
-    g = inverse(copy.deepcopy(termeq), v2)
+    t = inverse(termeq, v1)
+    g = inverse(termeq, v2)
     if g is None:
         return none
     if t is None:
-        return none
+        equation = simplify(factor2(factor0(simplify(replace(eq, g, tree_form(v2))/diff(g, v1)))))
+        if v1 in str_form(equation):        
+            return none
     else:
         t = expand(t)
         eq3 = diff(g, v1)
@@ -193,6 +199,9 @@ def integrate_subs(equation, term, v1, v2, extra):
             eq = replace(eq, tree_form(v1), t)
             equation = eq/eq3
             equation = simplify(equation)
+            if v1 in str_form(equation):
+                equation = replace(equation, tree_form(v1), t)
+                equation = formula_applier(equation, "abs(x) x [] _ _ _ _")
     if v1 in str_form(equation):
         return none
     return dowhile(TreeNode("f_subs", [TreeNode("f_integrate", [simplify(equation), tree_form(origv2)]),tree_form(origv2) ,g]+extra), lambda x: simplify(trig4(trig0(x))))
@@ -321,13 +330,14 @@ def integrate_full(root):
         return "f_integrate" not in str_form(x)
     result = None
     root = normalize(root)
+    root = formula_applier(root, "(a^b)^c a^(b*c) [] b c _ _")
     normalize2 = lambda x: normalize(x, False)
     log = []
     orig = copy.deepcopy(root)
     eq = root
     for item in [[lambda x: x, simplify, expand, normalize], [factor2, apart, normalize2, normalize], [trig1, normalize2],\
                  [factor1, normalize, trig6, normalize, expand, normalize, integrate_subs_main, normalize, factor2, simplify, integrate_trig_formula, trig1, apart, normalize2],\
-                 [normalize, integrate_subs_main, normalize2, expand, normalize, byparts, normalize], [simplify, integrate_trig_formula, trig1, integrate_formula]]:
+                 [normalize2, integrate_subs_main, expand, normalize, byparts, normalize], [simplify, integrate_trig_formula, trig1, integrate_formula]]:
         for item2 in item:
             eq = item2(eq)
             if eq not in log:

{mathai-2.3.6 → mathai-2.3.8}/mathai/linear.py

@@ -100,6 +100,42 @@ def linear_solve(eq, lst=None):
     else:
         return eq
         
+    fxconst = (lambda x: False) if lst is None else (lambda x: any(contain(x, item) for item in lst))
+    
+    # 1. Collect all non-constant variables (vl) across all equations
+    vl = []
+    def varlist(node, fxconst):
+        nonlocal vl
+        if node.name[:2] == "v_" and not fxconst(node):
+            vl.append(node.name)
+        for child in node.children:
+            varlist(child, fxconst)
+            
+    for item in eqlist:
+        varlist(item, fxconst)
+    vl = sorted(list(set(vl)))
+
+    # 2. Check linearity by iterating through all equations and variables:
+    # If diff w.r.t a variable still contains any variable from vl, it's non-linear.
+    for eq_item in eqlist:
+        for v in vl:
+            d = simplify(diff(eq_item, v))
+            
+            # Helper to check if derivative 'd' contains any variable from vl
+            contains_var = False
+            def check_vars(node):
+                nonlocal contains_var
+                if node.name[:2] == "v_" and node.name in vl:
+                    contains_var = True
+                    return
+                for child in node.children:
+                    check_vars(child)
+            
+            check_vars(d)
+            if contains_var:
+                return None  # Non-linear expression detected
+
+    # 3. Proceed with linear solver and rref if check passes
     out = None
     if lst is None:
         out = linear(copy.deepcopy(eqlist), lambda x: False)