mathai 2.3.5__tar.gz → 2.3.7__tar.gz

{mathai-2.3.5 → mathai-2.3.7}/PKG-INFO

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

{mathai-2.3.5 → mathai-2.3.7}/mathai/__init__.py

@@ -5,7 +5,7 @@ from .pde import solve_pde
 
 from .qm import hydrogen_gse, helium_gse, power_rule
 
-from .graphics import draw_graphics_from_solution
+from .graphics import draw_graphics_from_solution, solve_graphics, solve_graphics_string
 
 from .lambda_calculus import lambda_expand, lambda_compress, lambda_reduce
 
@@ -15,9 +15,7 @@ from .linear import linear_solve
 
 from .test import test
 
-from .decision import god, trig7
-
-from .graphics import solve_graphics, solve_graphics_string
+from .decision import god
 
 from .expand import expand
 
@@ -32,12 +30,10 @@ from .formula_applier import formula_applier, formula_list_applier
 
 from .integrate import integrate_subs_main as integrate_subs
 from .integrate import byparts as integrate_byparts
-from .integrate import sqint as integrate_fraction
-from .integrate import conv_int
+from .integrate import integrate_fraction
 from .integrate import solve_integrate as integrate_clean
-from .integrate import integrate_formula, integrate_trig_formula, integrate_qm_formula, integrate_full, integrate_definite
+from .integrate import integrate_formula, integrate_trig_formula, integrate_full, def_integrate_formula
 from .integrate import normalize as integration_basic
-from .integrate import normalize_qm as integration_qm_basic
 
 from .diff import diff, diff2
 
@@ -54,11 +50,11 @@ from .inverse import inverse, inverse2
 from .logic import logic0, set_sub, truth_gen, solve_logically
 from .apart import apart, apart2
 
-from .limit import limit1, limit2, limit0, limit3, limit4, solve_inf
+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.7/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.7/mathai/diff.py

@@ -0,0 +1,179 @@
+from .simplify import simplify
+from .base import *
+from .parser import parse
+from .formula_applier import formula_list_applier
+
+diff2_s = """pdif(e^a,x) e^a*pdif(a,x) [] x _ _ _
+pdif(a^b,x) b*(a^(b-1))*pdif(a,x)+(a^b)*log(a)*pdif(b,x) [] x _ _ _
+pdif(sin(a),x) cos(a)*pdif(a,x) [] x _ _ _
+pdif(cos(a),x) -sin(a)*pdif(a,x) [] x _ _ _
+pdif(arcsin(a),x) (1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
+pdif(arccos(a),x) (-1/sqrt(1-a^2))*pdif(a,x) [] x _ _ _
+pdif(arctan(a),x) (1/(1+a^2))*pdif(a,x) [] x _ _ _
+pdif(k,x) 0 [] x k _ _
+pdif(x,x) 1 [] x _ _ _
+pdif(product(a,b),x) pdif(a,x)*b+a*pdif(b,x) [] x _ _ _
+pdif(sum(a,b),x) pdif(a,x)+pdif(b,x) [] x _ _ _
+pdif(product(k,a),x) k*pdif(a,x) [] x k _ _"""
+
+diff2 = lambda x: formula_list_applier(x, diff2_s)
+'''
+def diff(equation, var=None):
+    var = var if var else "v_0"
+    out = diff2(simplify(TreeNode("f_pdif", [equation, tree_form(var)])))
+    return out
+'''
+def diff(equation, var="v_0"):
+    def diffeq_iterative(root_eq):
+        stack = [(root_eq, False)]
+        results = {}
+        while stack:
+            eq, processed = stack.pop()
+            if eq in results:
+                continue
+            if not processed:
+                eq_simplified = simplify(eq)
+                if "v_" not in str_form(eq_simplified):
+                    results[eq] = tree_form("d_0")
+                    continue
+                stack.append((eq, True))
+                if eq.name in ("f_add", "f_mul"):
+                    for child in eq.children:
+                        if child not in results:
+                            stack.append((child, False))
+                elif eq.name in ("f_abs", "f_tan", "f_log", "f_arcsin", "f_arccos", "f_arctan", "f_sin", "f_cos"):
+                    child = eq.children[0]
+                    if child not in results:
+                        stack.append((child, False))
+                elif eq.name == "f_pow":
+                    for child in eq.children:
+                        if child not in results:
+                            stack.append((child, False))
+            else:
+                if "v_" not in str_form(eq):
+                    results[eq] = tree_form("d_0")
+                    continue
+                if eq.name == "f_add":
+                    add_res = tree_form("d_0")
+                    for child in eq.children:
+                        add_res = add_res + results.get(child, tree_form("d_0"))
+                    results[eq] = add_res
+                elif eq.name == "f_abs":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * u / eq
+                elif eq.name == "f_pow" and eq.children[0].name == "s_e":
+                    u = eq.children[1]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * eq
+                elif eq.name == "f_tan":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    cos_u = u.fx("cos")
+                    results[eq] = du / (cos_u * cos_u)
+                elif eq.name == "f_log":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * (tree_form("d_1") / u)
+                elif eq.name == "f_arcsin":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    one = tree_form("d_1")
+                    half = tree_form("d_2") ** tree_form("d_-1")
+                    results[eq] = du / ((one - u * u) ** half)
+                elif eq.name == "f_arccos":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    one = tree_form("d_1")
+                    half = tree_form("d_2") ** tree_form("d_-1")
+                    results[eq] = tree_form("d_-1") * du / ((one - u * u) ** half)
+                elif eq.name == "f_arctan":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du / (tree_form("d_1") + u * u)
+                elif eq.name == "f_pow" and "v_" in str_form(eq.children[1]):
+                    u, v = eq.children
+                    du = results.get(u, tree_form("d_0"))
+                    dv = results.get(v, tree_form("d_0"))
+                    term1 = (v / u) * du
+                    term2 = u.fx("log") * dv
+                    results[eq] = (u ** v) * (term1 + term2)
+                elif eq.name == "f_mul":
+                    add_res = tree_form("d_0")
+                    n_children = len(eq.children)
+                    for i in range(n_children):
+                        target_child = eq.children[i]
+                        d_target = results.get(target_child, tree_form("d_0"))
+                        other_terms = [eq.children[j] for j in range(n_children) if j != i]
+                        if len(other_terms) == 1:
+                            other_prod = other_terms[0]
+                        else:
+                            other_prod = TreeNode("f_mul", other_terms)
+                        add_res = add_res + (d_target * other_prod)
+                    results[eq] = add_res
+                elif eq.name == "f_sin":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = du * u.fx("cos")
+                elif eq.name == "f_cos":
+                    u = eq.children[0]
+                    du = results.get(u, tree_form("d_0"))
+                    results[eq] = tree_form("d_-1") * du * u.fx("sin")
+                elif eq.name[:2] == "v_":
+                    results[eq] = TreeNode("f_dif", [eq])
+                elif eq.name == "f_pow" and "v_" not in str_form(eq.children[1]):
+                    base, power = eq.children
+                    dbase = results.get(base, tree_form("d_0"))
+                    power_minus_1 = power - tree_form("d_1")
+                    results[eq] = power * (base ** power_minus_1) * dbase
+                else:
+                    results[eq] = TreeNode("f_dif", [eq, tree_form(var)])
+        return results.get(root_eq, tree_form("d_0"))
+    def helper2_iterative(root_eq, target_var):
+        stack = [(root_eq, False)]
+        results = {}
+        while stack:
+            eq, processed = stack.pop()
+            if eq in results:
+                continue
+            if not processed:
+                stack.append((eq, True))
+                for child in eq.children:
+                    if child not in results:
+                        stack.append((child, False))
+            else:
+                if eq.name == "f_dif":
+                    if eq.children[0].name == target_var:
+                        results[eq] = tree_form("d_1")
+                    elif not contain(eq.children[0], target_var):
+                        results[eq] = tree_form("d_0")
+                    else:
+                        results[eq] = eq
+                else:
+                    new_children = [results.get(child, child) for child in eq.children]
+                    results[eq] = TreeNode(eq.name, new_children)
+        return results.get(root_eq, root_eq)
+    def calc_iterative(root_eq):
+        stack = [(root_eq, False)]
+        results = {}
+        while stack:
+            eq, processed = stack.pop()
+            if eq in results:
+                continue
+            if not processed:
+                stack.append((eq, True))
+                for child in eq.children:
+                    if child not in results:
+                        stack.append((child, False))
+            else:
+                if eq.name == "f_dif":
+                    results[eq] = diffeq_iterative(eq.children[0])
+                else:
+                    new_children = [results.get(child, child) for child in eq.children]
+                    results[eq] = TreeNode(eq.name, new_children)
+        return results.get(root_eq, root_eq)
+    if var is None:
+        return simplify(calc_iterative(equation))
+    equation = diffeq_iterative(equation)
+    equation = helper2_iterative(equation, var)
+    return simplify(equation)

{mathai-2.3.5 → mathai-2.3.7}/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
@@ -253,8 +271,10 @@ def _match_struct_bind_core(eq, f, binding, const_1_vars, ignore_set, resolved_i
         for item in vlist(eq):
             out = extract_polynomial_coefficients(eq_plain, item, degree)
             if out is not None:
-                out = out[::-1][1:]
-                if out[0] != 0:
+                out = out[::-1]
+                while len(out) != 0 and out[0] == 0:
+                    out.pop(0)
+                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]
@@ -291,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:
@@ -389,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)
@@ -402,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
         )
@@ -421,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):
@@ -484,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
 
@@ -547,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):
@@ -592,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)
@@ -609,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)