Upload 13 files

advanced_math_engine.py

@@ -0,0 +1,994 @@
+"""
+Advanced Math Engine v2 — symbolic computation using SymPy.
+
+Handles a wide range of advanced mathematics:
+    ─ Indefinite & definite integration
+    ─ Differentiation (any order, any variable)
+    ─ Limits (including one-sided and infinity)
+    ─ Equation & system solving
+    ─ Ordinary differential equations (ODEs)
+    ─ Matrix operations (det, inverse, eigenvalues, rank, trace)
+    ─ Taylor / Maclaurin series expansion
+    ─ Laplace & inverse Laplace transforms
+    ─ Fourier transform
+    ─ Simplification, factoring, expansion, partial fractions
+    ─ Number theory (GCD, LCM, prime factorization, modular arithmetic)
+    ─ Statistics (mean, variance, std deviation, median)
+    ─ Combinatorics (factorial, binomial coefficients, permutations)
+    ─ Complex number operations
+    ─ Summations & products
+    ─ Trigonometric identity simplification
+
+The engine parses natural language ("integrate x^2 sin(x)"), runs the
+computation symbolically with SymPy, and returns:
+    - a clean string result
+    - a LaTeX representation
+
+The result is then handed to the LLM, which is TOLD the correct answer
+and must only produce the step-by-step explanation — preventing hallucination.
+"""
+
+import re
+from typing import Optional, Tuple
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Operation keyword registry
+# ─────────────────────────────────────────────────────────────────────────────
+
+_ADVANCED_OPS: dict[str, list[str]] = {
+    "integrate": [
+        "integrate", "integral of", "antiderivative of", "indefinite integral",
+        "definite integral", "∫",
+    ],
+    "differentiate": [
+        "differentiate", "derivative of", "d/dx", "d/dy", "d/dz", "d/dt",
+        "diff of", "first derivative", "second derivative", "third derivative",
+        "nth derivative", "partial derivative",
+    ],
+    "limit": [
+        "limit of", "limit as", "lim ", "lim(", "find the limit",
+    ],
+    "solve": [
+        "solve ", "find roots of", "zeros of", "find x such that",
+        "find the value of x", "find the solution",
+    ],
+    "ode": [
+        "differential equation", "ode ", "ordinary differential",
+        "dsolve", "solve the ode", "solve ode", "y'' ", "y' ",
+        "d2y", "d^2y", "solve the differential",
+    ],
+    "eigenvalue": [
+        "eigenvalue", "eigenvector", "eigen value", "eigen vector",
+        "characteristic polynomial",
+    ],
+    "determinant": [
+        "determinant of", "det of", "det(",
+    ],
+    "inverse": [
+        "inverse of matrix", "matrix inverse", "inverse matrix",
+    ],
+    "matrix_rank": [
+        "rank of matrix", "matrix rank", "rank(",
+    ],
+    "matrix_trace": [
+        "trace of matrix", "matrix trace", "trace(",
+    ],
+    "series": [
+        "taylor series", "maclaurin series", "series expansion",
+        "expand in series", "power series",
+    ],
+    "laplace": [
+        "laplace transform", "laplace of", "l{", "l(",
+    ],
+    "inverse_laplace": [
+        "inverse laplace", "laplace inverse", "l^-1",
+    ],
+    "fourier": [
+        "fourier transform", "fourier of",
+    ],
+    "simplify": [
+        "simplify ", "simplify(", "reduce ",
+    ],
+    "trig_simplify": [
+        "simplify trig", "trig simplif", "trigonometric simplif",
+        "simplify the trigonometric",
+    ],
+    "factor": [
+        "factor ", "factorise ", "factorize ", "factorise(", "factor(",
+    ],
+    "expand": [
+        "expand ", "expand(",
+    ],
+    "partial_fraction": [
+        "partial fraction", "partial fractions", "partial fraction decomposition",
+    ],
+    "gcd": [
+        "gcd(", "gcd of", "greatest common divisor", "highest common factor",
+        "hcf of",
+    ],
+    "lcm": [
+        "lcm(", "lcm of", "least common multiple", "lowest common multiple",
+    ],
+    "prime_factors": [
+        "prime factor", "prime factorization", "factorise into primes",
+        "factorize into primes", "prime decomposition",
+    ],
+    "modular": [
+        " mod ", "modulo ", "modular arithmetic", "modular inverse",
+        "congruence",
+    ],
+    "statistics": [
+        "mean of", "average of", "median of", "mode of",
+        "variance of", "standard deviation of", "std dev of", "std(",
+        "statistics of",
+    ],
+    "factorial": [
+        "factorial of", "factorial(", "! ", "n factorial",
+    ],
+    "binomial": [
+        "binomial coefficient", "choose ", "c(", "combinations of",
+        "nCr",
+    ],
+    "permutation": [
+        "permutation", "nPr", "arrangements of",
+    ],
+    "summation": [
+        "sum of ", "summation of", "sigma notation", "∑",
+    ],
+    "product": [
+        "product of ", "∏", "pi product",
+    ],
+    "complex_ops": [
+        "complex number", "real part", "imaginary part", "modulus of",
+        "argument of", "conjugate of",
+    ],
+}
+
+
+def detect_advanced_operation(text: str) -> Optional[str]:
+    """Return the detected advanced math operation (highest-priority match), or None."""
+    lowered = text.lower()
+
+    # Priority ordering — more specific ops first
+    priority_order = [
+        "trig_simplify", "inverse_laplace", "laplace", "fourier",
+        "ode", "eigenvalue", "determinant", "inverse", "matrix_rank",
+        "matrix_trace", "partial_fraction", "prime_factors", "modular",
+        "statistics", "binomial", "permutation", "factorial",
+        "summation", "product", "complex_ops", "gcd", "lcm",
+        "integrate", "differentiate", "limit", "series",
+        "simplify", "factor", "expand", "solve",
+    ]
+
+    for op in priority_order:
+        keywords = _ADVANCED_OPS.get(op, [])
+        for kw in keywords:
+            if kw in lowered:
+                return op
+    return None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Expression helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _preprocess(expr: str) -> str:
+    """Normalise user-written math to SymPy-parseable syntax."""
+    expr = expr.strip()
+    # Remove trailing differential (dx, dy, dt, …) for integrals
+    expr = re.sub(r'\s*d[a-zA-Z]\s*$', '', expr)
+    # Remove "= 0" for equation solving — SymPy's solve() takes LHS
+    expr = re.sub(r'\s*=\s*0\s*$', '', expr)
+    # Replace ^ with **
+    expr = expr.replace('^', '**')
+    # Natural log → log
+    expr = re.sub(r'\bln\b', 'log', expr)
+    # arc functions
+    expr = re.sub(r'\barc(sin|cos|tan)\b', r'a\1', expr)
+    return expr.strip()
+
+
+def _parse(expr_str: str):
+    """
+    Parse a string into a SymPy expression.
+    Uses implicit multiplication so "x sin(x)" → x*sin(x).
+    Raises ValueError on failure.
+    """
+    from sympy.parsing.sympy_parser import (
+        parse_expr,
+        standard_transformations,
+        implicit_multiplication_application,
+        convert_xor,
+    )
+    from sympy import symbols
+    from sympy import (
+        sin, cos, tan, asin, acos, atan, sinh, cosh, tanh,
+        exp, log, sqrt, pi, E, oo, I, Abs,
+        sec, csc, cot, atan2, factorial, binomial,
+        ceiling, floor, sign, Heaviside,
+    )
+
+    transformations = standard_transformations + (
+        implicit_multiplication_application,
+        convert_xor,
+    )
+
+    local_dict = {v: symbols(v) for v in "xyztnkabcmnpqrs"}
+    local_dict.update({
+        "sin": sin, "cos": cos, "tan": tan,
+        "asin": asin, "acos": acos, "atan": atan,
+        "arcsin": asin, "arccos": acos, "arctan": atan,
+        "sinh": sinh, "cosh": cosh, "tanh": tanh,
+        "exp": exp, "log": log, "ln": log,
+        "sqrt": sqrt, "pi": pi, "e": E, "E": E,
+        "oo": oo, "inf": oo, "infinity": oo,
+        "I": I, "j": I, "abs": Abs, "Abs": Abs,
+        "sec": sec, "csc": csc, "cot": cot, "atan2": atan2,
+        "factorial": factorial, "binomial": binomial,
+        "ceil": ceiling, "floor": floor, "sign": sign,
+        "Heaviside": Heaviside, "H": Heaviside,
+    })
+
+    cleaned = _preprocess(expr_str)
+    try:
+        return parse_expr(cleaned, local_dict=local_dict,
+                          transformations=transformations,
+                          evaluate=True)
+    except Exception as exc:
+        raise ValueError(f"Cannot parse '{expr_str}': {exc}")
+
+
+def _extract_variable(text: str, default: str = "x") -> str:
+    """Detect the primary variable from phrases like 'with respect to y'."""
+    m = re.search(r'with\s+respect\s+to\s+([a-zA-Z])', text, re.I)
+    if m:
+        return m.group(1)
+    m = re.search(r'\bwrt\s+([a-zA-Z])', text, re.I)
+    if m:
+        return m.group(1)
+    m = re.search(r'\bd/d([a-zA-Z])', text, re.I)
+    if m:
+        return m.group(1)
+    return default
+
+
+def _strip_prefix(text: str, keywords: list[str]) -> str:
+    """Remove any matching operation prefix from the text."""
+    lowered = text.lower()
+    for kw in sorted(keywords, key=len, reverse=True):
+        if lowered.startswith(kw):
+            return text[len(kw):].strip()
+    for kw in sorted(keywords, key=len, reverse=True):
+        idx = lowered.find(kw)
+        if idx != -1:
+            return text[idx + len(kw):].strip()
+    return text.strip()
+
+
+def _parse_matrix(text: str):
+    """Extract and parse a matrix from text like [[1,2],[3,4]]."""
+    from sympy import Matrix
+    m = re.search(r'\[\[.*?\]\]', text, re.DOTALL)
+    if not m:
+        raise ValueError(
+            "Please provide the matrix in format [[a,b],[c,d]] — e.g. [[1,2],[3,4]]"
+        )
+    mat_raw = m.group(0)
+    mat_data = eval(mat_raw)
+    return Matrix(mat_data)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Operation handlers
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _handle_integrate(text: str) -> Tuple[str, str]:
+    from sympy import integrate, symbols, latex
+
+    var_name = _extract_variable(text)
+    var = symbols(var_name)
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["integrate"])
+    # Remove "with respect to X" from expression text
+    expr_text = re.sub(r'\s+with\s+respect\s+to\s+[a-zA-Z]\s*$', '', expr_text, flags=re.I).strip()
+    expr_text = re.sub(r'\bwrt\s+[a-zA-Z]\s*$', '', expr_text, flags=re.I).strip()
+
+    # Definite integral: "EXPR from A to B"
+    m = re.search(
+        r'(.*?)\s+from\s+([\w\.\-\+eEpioo∞infty]+)\s+to\s+([\w\.\-\+eEpioo∞infty]+)',
+        expr_text, re.I
+    )
+
+    def _parse_bound(raw: str):
+        raw = raw.replace("infty", "oo").replace("∞", "oo").replace("infinity", "oo")
+        import sympy
+        if raw == "oo":  return sympy.oo
+        if raw == "-oo": return -sympy.oo
+        return _parse(raw)
+
+    if m:
+        expr   = _parse(m.group(1).strip())
+        lower  = _parse_bound(m.group(2).strip())
+        upper  = _parse_bound(m.group(3).strip())
+        result = integrate(expr, (var, lower, upper))
+        return (
+            f"∫ ({expr}) d{var_name} from {lower} to {upper} = {result}",
+            latex(result),
+        )
+    else:
+        expr   = _parse(expr_text)
+        result = integrate(expr, var)
+        return (
+            f"∫ ({expr}) d{var_name} = {result} + C",
+            latex(result) + " + C",
+        )
+
+
+def _handle_differentiate(text: str) -> Tuple[str, str]:
+    from sympy import diff, symbols, latex
+
+    var_name = _extract_variable(text)
+    var = symbols(var_name)
+
+    _ORDINAL_MAP = {
+        "second": 2, "2nd": 2, "third": 3, "3rd": 3,
+        "fourth": 4, "4th": 4, "fifth": 5, "5th": 5,
+        "sixth": 6, "6th": 6, "seventh": 7, "7th": 7,
+        "eighth": 8, "8th": 8, "ninth": 9, "9th": 9,
+    }
+    order = 1
+    m_order = re.search(
+        r'\b(second|2nd|third|3rd|fourth|4th|fifth|5th|sixth|6th|'
+        r'seventh|7th|eighth|8th|ninth|9th)\s+derivative\b',
+        text, re.I
+    )
+    if m_order:
+        order = _ORDINAL_MAP[m_order.group(1).lower()]
+
+    expr_text = text
+    expr_text = re.sub(
+        r'(?:second|2nd|third|3rd|fourth|4th|fifth|5th|sixth|6th|'
+        r'seventh|7th|eighth|8th|ninth|9th)?\s*(?:partial\s+)?derivative\s+of\s+',
+        '', expr_text, flags=re.I
+    ).strip()
+    expr_text = _strip_prefix(expr_text, _ADVANCED_OPS["differentiate"])
+    expr_text = re.sub(r'^of\s+', '', expr_text, flags=re.I).strip()
+    expr_text = re.sub(r'\s+with\s+respect\s+to\s+[a-zA-Z]\s*$', '', expr_text, flags=re.I).strip()
+    expr_text = re.sub(r'\bwrt\s+[a-zA-Z]\s*$', '', expr_text, flags=re.I).strip()
+
+    expr   = _parse(expr_text)
+    result = diff(expr, var, order)
+    order_label = {1: "d/d", 2: "d²/d", 3: "d³/d"}.get(order, f"d^{order}/d")
+    return (
+        f"{order_label}{var_name}[{expr}] = {result}",
+        latex(result),
+    )
+
+
+def _handle_limit(text: str) -> Tuple[str, str]:
+    from sympy import limit, symbols, latex, oo
+
+    var_name = _extract_variable(text, default="x")
+    var = symbols(var_name)
+
+    m = re.search(
+        r'(?:limit\s+of\s+|lim\s+)?(.+?)\s+as\s+'
+        rf'{var_name}\s+(?:->|→|approaches|tends\s+to)\s+([^\s,]+)',
+        text, re.I
+    )
+
+    if m:
+        expr_raw  = m.group(1).strip()
+        point_raw = m.group(2).strip()
+    else:
+        m2 = re.search(
+            rf'lim\s+{var_name}\s*[-→>]{{1,2}}\s*([^\s]+)\s+(.+)', text, re.I
+        )
+        if m2:
+            point_raw = m2.group(1)
+            expr_raw  = m2.group(2)
+        else:
+            raise ValueError(
+                "Could not parse limit. Expected: 'limit of EXPR as x approaches VALUE'"
+            )
+
+    point_raw = (point_raw.replace("infinity", "oo")
+                          .replace("∞", "oo")
+                          .replace("infty", "oo"))
+    import sympy
+    if point_raw == "oo":   point = oo
+    elif point_raw == "-oo": point = -oo
+    else: point = _parse(point_raw)
+
+    expr   = _parse(expr_raw)
+    result = limit(expr, var, point)
+    return (
+        f"lim({expr}) as {var_name} → {point} = {result}",
+        sympy.latex(result),
+    )
+
+
+def _handle_solve(text: str) -> Tuple[str, str]:
+    from sympy import solve, symbols, Eq, latex
+
+    var_name = _extract_variable(text)
+    var = symbols(var_name)
+
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["solve"])
+    expr_text = re.sub(r'\s+for\s+[a-zA-Z]$', '', expr_text.strip(), flags=re.I)
+
+    if '=' in expr_text:
+        parts = expr_text.split('=', 1)
+        lhs = _parse(parts[0].strip())
+        rhs = _parse(parts[1].strip())
+        solutions = solve(Eq(lhs, rhs), var)
+    else:
+        solutions = solve(_parse(expr_text), var)
+
+    if not solutions:
+        return (f"No solutions found for: {expr_text}", r"\text{No solution}")
+
+    sol_str   = ", ".join(str(s) for s in solutions)
+    sol_latex = ", ".join(latex(s) for s in solutions)
+    return (f"{var_name} = {sol_str}", sol_latex)
+
+
+def _handle_ode(text: str) -> Tuple[str, str]:
+    """Solve ordinary differential equations using SymPy's dsolve."""
+    from sympy import symbols, Function, dsolve, latex, Eq, Derivative
+    from sympy.parsing.sympy_parser import parse_expr
+
+    x = symbols('x')
+    y = Function('y')
+
+    # Normalise ^ to **
+    text_norm = text.replace('^', '**')
+
+    # Try to extract the ODE expression:
+    # Support patterns like:
+    #   "y'' + y = 0", "y' - 2y = 0", "dy/dx + y = x"
+    # We'll try to build the ODE equation
+
+    # Replace y'' → Derivative(y(x), x, 2), y' → Derivative(y(x), x)
+    # and y → y(x) in the expression
+    cleaned = text_norm
+    # Strip any leading prompt words
+    cleaned = re.sub(
+        r'(?:solve|ode|ordinary differential equation|differential equation|solve the ode|solve ode)[\s:]*',
+        '', cleaned, flags=re.I
+    ).strip()
+
+    # Replace notation
+    cleaned = re.sub(r"y''", "Derivative(y(x),x,2)", cleaned)
+    cleaned = re.sub(r"y'",  "Derivative(y(x),x)",   cleaned)
+    # dy/dx or d^2y/dx^2
+    cleaned = re.sub(r'd\*\*2y/dx\*\*2', 'Derivative(y(x),x,2)', cleaned)
+    cleaned = re.sub(r'd2y/dx2',          'Derivative(y(x),x,2)', cleaned)
+    cleaned = re.sub(r'dy/dx',            'Derivative(y(x),x)',   cleaned)
+    # bare y that isn't followed by ( — replace with y(x)
+    cleaned = re.sub(r'\by\b(?!\()', 'y(x)', cleaned)
+
+    local_dict = {
+        'x': x, 'y': y, 'Derivative': Derivative,
+    }
+    from sympy import sin, cos, exp, log, sqrt, pi, E, oo, tan
+    local_dict.update({
+        'sin': sin, 'cos': cos, 'exp': exp, 'log': log,
+        'sqrt': sqrt, 'pi': pi, 'e': E, 'tan': tan,
+    })
+
+    try:
+        if '=' in cleaned:
+            lhs_str, rhs_str = cleaned.split('=', 1)
+            lhs = parse_expr(lhs_str.strip(), local_dict=local_dict)
+            rhs = parse_expr(rhs_str.strip(), local_dict=local_dict)
+            ode_eq = Eq(lhs, rhs)
+        else:
+            expr = parse_expr(cleaned.strip(), local_dict=local_dict)
+            ode_eq = Eq(expr, 0)
+
+        sol = dsolve(ode_eq, y(x))
+        return (
+            f"ODE: {ode_eq}\nGeneral solution: {sol}",
+            latex(sol),
+        )
+    except Exception as exc:
+        raise ValueError(f"Could not solve ODE: {exc}")
+
+
+def _handle_eigenvalue(text: str) -> Tuple[str, str]:
+    from sympy import latex
+
+    mat = _parse_matrix(text)
+    eigs  = mat.eigenvals()
+    evecs = mat.eigenvects()
+
+    eig_str = "; ".join(
+        f"λ={ev} (multiplicity {mult})" for ev, mult in eigs.items()
+    )
+    evec_parts = []
+    for ev, mult, vecs in evecs:
+        for v in vecs:
+            evec_parts.append(f"λ={ev}: {v.T.tolist()}")
+    evec_str = "; ".join(evec_parts)
+
+    result_str = f"Eigenvalues: {eig_str}\nEigenvectors: {evec_str}"
+    return (result_str, eig_str)
+
+
+def _handle_determinant(text: str) -> Tuple[str, str]:
+    from sympy import latex
+
+    mat = _parse_matrix(text)
+    det = mat.det()
+    return (f"det = {det}", latex(det))
+
+
+def _handle_inverse(text: str) -> Tuple[str, str]:
+    from sympy import latex
+
+    mat = _parse_matrix(text)
+    inv = mat.inv()
+    return (f"Inverse matrix:\n{inv}", latex(inv))
+
+
+def _handle_matrix_rank(text: str) -> Tuple[str, str]:
+    mat = _parse_matrix(text)
+    rank = mat.rank()
+    return (f"Rank = {rank}", str(rank))
+
+
+def _handle_matrix_trace(text: str) -> Tuple[str, str]:
+    from sympy import latex
+    mat = _parse_matrix(text)
+    trace = mat.trace()
+    return (f"Trace = {trace}", latex(trace))
+
+
+def _handle_series(text: str) -> Tuple[str, str]:
+    from sympy import series, symbols, latex, oo
+
+    var_name = _extract_variable(text)
+    var = symbols(var_name)
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["series"])
+    # Strip leading "of" left after prefix removal
+    expr_text = re.sub(r'^of\s+', '', expr_text, flags=re.I).strip()
+
+    point = 0
+    m_point = re.search(r'(?:around|at|about|near)\s+([\w\.\-\+]+)', expr_text, re.I)
+    if m_point:
+        raw = m_point.group(1).replace("infinity", "oo").replace("∞", "oo")
+        point = oo if raw == "oo" else _parse(raw)
+        expr_text = expr_text[:m_point.start()].strip()
+
+    order = 6
+    m_order = re.search(r'(?:order|degree|up\s+to|terms?)\s+(\d+)', expr_text, re.I)
+    if m_order:
+        order = int(m_order.group(1))
+        expr_text = (expr_text[:m_order.start()] + expr_text[m_order.end():]).strip()
+
+    expr   = _parse(expr_text)
+    result = series(expr, var, point, n=order)
+    return (
+        f"Series of {expr} around {var_name}={point} (order {order}): {result}",
+        latex(result),
+    )
+
+
+def _handle_laplace(text: str) -> Tuple[str, str]:
+    from sympy import symbols, laplace_transform, latex
+
+    t, s = symbols('t s', positive=True)
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["laplace"])
+    expr_text = re.sub(r'\bof\b', '', expr_text, flags=re.I).strip()
+
+    expr = _parse(expr_text)
+    # With noconds=True SymPy returns the expression directly (not a tuple)
+    raw = laplace_transform(expr, t, s, noconds=True)
+    # Guard: some SymPy versions return a 3-tuple even with noconds=True
+    if isinstance(raw, tuple):
+        result = raw[0]
+    else:
+        result = raw
+    return (
+        f"L{{{expr}}} = {result}",
+        latex(result),
+    )
+
+
+def _handle_inverse_laplace(text: str) -> Tuple[str, str]:
+    from sympy import symbols, inverse_laplace_transform, latex, Symbol
+
+    # SymPy requires s to be declared positive for inverse Laplace
+    t_pos, s_pos = symbols('t s', positive=True)
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["inverse_laplace"])
+    expr_text = re.sub(r'\bof\b', '', expr_text, flags=re.I).strip()
+    expr = _parse(expr_text)
+    # Substitute any plain 's' or 't' with the positive versions
+    s_plain = Symbol('s')
+    t_plain = Symbol('t')
+    expr = expr.subs([(s_plain, s_pos), (t_plain, t_pos)])
+    result = inverse_laplace_transform(expr, s_pos, t_pos)
+    return (
+        f"L⁻¹{{{expr}}} = {result}",
+        latex(result),
+    )
+
+
+def _handle_fourier(text: str) -> Tuple[str, str]:
+    from sympy import symbols, fourier_transform, latex
+
+    x, k = symbols('x k')
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["fourier"])
+    expr_text = re.sub(r'\bof\b', '', expr_text, flags=re.I).strip()
+    expr = _parse(expr_text)
+    result = fourier_transform(expr, x, k)
+    return (
+        f"F{{{expr}}} = {result}",
+        latex(result),
+    )
+
+
+def _handle_simplify(text: str) -> Tuple[str, str]:
+    from sympy import simplify, latex
+
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["simplify"])
+    expr   = _parse(expr_text)
+    result = simplify(expr)
+    return (f"Simplified: {result}", latex(result))
+
+
+def _handle_trig_simplify(text: str) -> Tuple[str, str]:
+    from sympy import trigsimp, latex
+
+    # strip any trig-specific prefix then fall through
+    expr_text = re.sub(
+        r'simplif[y]?\s+(?:the\s+)?trigonometric\s+|trig\s+simplif[y]?\s+|simplif[y]?\s+trig\s+',
+        '', text, flags=re.I
+    ).strip()
+    expr   = _parse(expr_text)
+    result = trigsimp(expr)
+    return (f"Trig-simplified: {result}", latex(result))
+
+
+def _handle_factor(text: str) -> Tuple[str, str]:
+    from sympy import factor, latex
+
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["factor"])
+    expr   = _parse(expr_text)
+    result = factor(expr)
+    return (f"Factored: {result}", latex(result))
+
+
+def _handle_expand(text: str) -> Tuple[str, str]:
+    from sympy import expand, latex
+
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["expand"])
+    expr   = _parse(expr_text)
+    result = expand(expr)
+    return (f"Expanded: {result}", latex(result))
+
+
+def _handle_partial_fraction(text: str) -> Tuple[str, str]:
+    from sympy import apart, symbols, latex
+
+    var_name = _extract_variable(text)
+    var = symbols(var_name)
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["partial_fraction"])
+    expr   = _parse(expr_text)
+    result = apart(expr, var)
+    return (f"Partial fractions of {expr}: {result}", latex(result))
+
+
+def _handle_gcd(text: str) -> Tuple[str, str]:
+    from sympy import gcd, latex
+
+    # Extract numbers from text
+    numbers = re.findall(r'\d+', text)
+    if len(numbers) < 2:
+        raise ValueError("Please provide at least two numbers. Example: GCD of 48 and 18")
+    from sympy import Integer
+    result = Integer(numbers[0])
+    for n in numbers[1:]:
+        result = gcd(result, Integer(n))
+    nums_str = ", ".join(numbers)
+    return (f"GCD({nums_str}) = {result}", latex(result))
+
+
+def _handle_lcm(text: str) -> Tuple[str, str]:
+    from sympy import lcm, latex
+
+    numbers = re.findall(r'\d+', text)
+    if len(numbers) < 2:
+        raise ValueError("Please provide at least two numbers. Example: LCM of 12 and 18")
+    from sympy import Integer
+    result = Integer(numbers[0])
+    for n in numbers[1:]:
+        result = lcm(result, Integer(n))
+    nums_str = ", ".join(numbers)
+    return (f"LCM({nums_str}) = {result}", latex(result))
+
+
+def _handle_prime_factors(text: str) -> Tuple[str, str]:
+    from sympy import factorint, latex
+
+    numbers = re.findall(r'\d+', text)
+    if not numbers:
+        raise ValueError("Please provide a number. Example: prime factorization of 360")
+    n = int(numbers[0])
+    factors = factorint(n)
+    factor_str = " × ".join(
+        f"{p}^{e}" if e > 1 else str(p) for p, e in sorted(factors.items())
+    )
+    return (f"{n} = {factor_str}", factor_str)
+
+
+def _handle_modular(text: str) -> Tuple[str, str]:
+    from sympy import mod_inverse, Integer
+
+    # modular inverse: "modular inverse of A mod M"
+    m_inv = re.search(
+        r'modular\s+inverse\s+of\s+(\d+)\s+mod\s+(\d+)', text, re.I
+    )
+    if m_inv:
+        a, m_val = int(m_inv.group(1)), int(m_inv.group(2))
+        inv = mod_inverse(a, m_val)
+        return (f"Modular inverse of {a} mod {m_val} = {inv}", str(inv))
+
+    # plain modulo: "A mod B"
+    m_mod = re.search(r'(\d+)\s+mod(?:ulo)?\s+(\d+)', text, re.I)
+    if m_mod:
+        a, m_val = int(m_mod.group(1)), int(m_mod.group(2))
+        result = a % m_val
+        return (f"{a} mod {m_val} = {result}", str(result))
+
+    raise ValueError(
+        "Could not parse modular arithmetic. "
+        "Try: '17 mod 5' or 'modular inverse of 3 mod 7'"
+    )
+
+
+def _handle_statistics(text: str) -> Tuple[str, str]:
+    from sympy.stats import Normal
+    from sympy import Rational, latex
+
+    # Extract list of numbers from text
+    numbers = re.findall(r'-?\d+(?:\.\d+)?', text)
+    if not numbers:
+        raise ValueError(
+            "Please provide a list of numbers. Example: mean of 2, 4, 6, 8"
+        )
+    vals = [float(n) for n in numbers]
+    n = len(vals)
+    mean   = sum(vals) / n
+    sorted_vals = sorted(vals)
+    if n % 2 == 0:
+        median = (sorted_vals[n//2 - 1] + sorted_vals[n//2]) / 2
+    else:
+        median = sorted_vals[n//2]
+    variance = sum((v - mean) ** 2 for v in vals) / n
+    std_dev  = variance ** 0.5
+
+    result_str = (
+        f"Data: {vals}\n"
+        f"Mean = {mean:.6g}\n"
+        f"Median = {median:.6g}\n"
+        f"Variance = {variance:.6g}\n"
+        f"Std Dev = {std_dev:.6g}"
+    )
+    return (result_str, result_str.replace("\n", r" \\ "))
+
+
+def _handle_factorial(text: str) -> Tuple[str, str]:
+    from sympy import factorial, latex, Integer
+
+    numbers = re.findall(r'\d+', text)
+    if not numbers:
+        raise ValueError("Please provide a number. Example: factorial of 10")
+    n = int(numbers[0])
+    if n > 1000:
+        raise ValueError("Number too large for factorial (max 1000)")
+    result = factorial(Integer(n))
+    return (f"{n}! = {result}", latex(result))
+
+
+def _handle_binomial(text: str) -> Tuple[str, str]:
+    from sympy import binomial as sym_binomial, latex, Integer
+
+    numbers = re.findall(r'\d+', text)
+    if len(numbers) < 2:
+        raise ValueError("Please provide n and r. Example: binomial coefficient 10 choose 3")
+    n, r = int(numbers[0]), int(numbers[1])
+    result = sym_binomial(Integer(n), Integer(r))
+    return (f"C({n}, {r}) = {result}", latex(result))
+
+
+def _handle_permutation(text: str) -> Tuple[str, str]:
+    from sympy import factorial, latex, Integer
+
+    numbers = re.findall(r'\d+', text)
+    if len(numbers) < 2:
+        raise ValueError("Please provide n and r. Example: permutation 10 P 3")
+    n, r = int(numbers[0]), int(numbers[1])
+    result = factorial(Integer(n)) // factorial(Integer(n - r))
+    return (f"P({n}, {r}) = {result}", latex(result))
+
+
+def _handle_summation(text: str) -> Tuple[str, str]:
+    from sympy import summation, symbols, oo, latex
+
+    # Try to detect summation variable from "for X=" or "for X from" pattern
+    m_var = re.search(r'\bfor\s+([a-zA-Z])\s*(?:=|from)\b', text, re.I)
+    if m_var:
+        var_name = m_var.group(1)
+    else:
+        var_name = _extract_variable(text, default="k")
+    var = symbols(var_name)
+
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["summation"])
+    # Strip leading "of" left after prefix removal
+    expr_text = re.sub(r'^of\s+', '', expr_text, flags=re.I).strip()
+
+    # Pattern A: "EXPR for k=A to B" or "EXPR for k from A to B"
+    m = re.search(
+        rf'(.*?)\s+for\s+{var_name}\s*(?:=|from)\s*(-?[\w\.]+)\s+to\s+(-?[\w\.∞]+)',
+        expr_text, re.I
+    )
+    # Pattern B: "EXPR from k=A to B"
+    if not m:
+        m = re.search(
+            rf'(.*?)\s+from\s+{var_name}\s*=\s*(-?[\w\.]+)\s+to\s+(-?[\w\.∞]+)',
+            expr_text, re.I
+        )
+
+    def _parse_bound(raw: str):
+        raw = raw.replace("infinity", "oo").replace("∞", "oo").replace("infty", "oo")
+        if raw == "oo":  return oo
+        if raw == "-oo": return -oo
+        return _parse(raw)
+
+    if m:
+        expr_raw = m.group(1).strip()
+        lo       = _parse_bound(m.group(2))
+        hi       = _parse_bound(m.group(3))
+        expr     = _parse(expr_raw)
+        result   = summation(expr, (var, lo, hi))
+        return (
+            f"Σ({expr}, {var_name}={lo}..{hi}) = {result}",
+            latex(result),
+        )
+    else:
+        expr   = _parse(expr_text)
+        result = summation(expr, (var, 0, oo))
+        return (
+            f"Σ({expr}, {var_name}=0..∞) = {result}",
+            latex(result),
+        )
+
+
+def _handle_product(text: str) -> Tuple[str, str]:
+    from sympy import Product, symbols, oo, latex
+
+    var_name = _extract_variable(text, default="k")
+    var = symbols(var_name)
+
+    expr_text = _strip_prefix(text, _ADVANCED_OPS["product"])
+    m = re.search(
+        rf'(.*?)\s+(?:for|from)\s+{var_name}\s*=\s*(-?\w+)\s+to\s+(-?\w+)',
+        expr_text, re.I
+    )
+    if m:
+        expr_raw = m.group(1).strip()
+        lo_raw   = m.group(2).replace("infty", "oo")
+        hi_raw   = m.group(3).replace("infty", "oo")
+        expr = _parse(expr_raw)
+        lo   = oo if lo_raw == "oo" else _parse(lo_raw)
+        hi   = oo if hi_raw == "oo" else _parse(hi_raw)
+        result = Product(expr, (var, lo, hi)).doit()
+        return (
+            f"∏({expr}, {var_name}={lo}..{hi}) = {result}",
+            latex(result),
+        )
+    else:
+        expr = _parse(expr_text)
+        result = Product(expr, (var, 1, oo)).doit()
+        return (
+            f"∏({expr}, {var_name}=1..∞) = {result}",
+            latex(result),
+        )
+
+
+def _handle_complex_ops(text: str) -> Tuple[str, str]:
+    from sympy import re as Re, im as Im, Abs, arg, conjugate, latex, symbols, I
+
+    # Try to extract a complex expression
+    # Strip common prefixes
+    clean = re.sub(
+        r'(?:real\s+part\s+of|imaginary\s+part\s+of|modulus\s+of|argument\s+of|conjugate\s+of|complex\s+number)\s*',
+        '', text, flags=re.I
+    ).strip()
+
+    expr = _parse(clean)
+
+    results = {
+        "Real part":      Re(expr),
+        "Imaginary part": Im(expr),
+        "Modulus":        Abs(expr),
+        "Argument":       arg(expr),
+        "Conjugate":      conjugate(expr),
+    }
+
+    lines = [f"{k} = {v}" for k, v in results.items()]
+    result_str  = "\n".join(lines)
+    result_latex = r" \\ ".join(f"{k} = {latex(v)}" for k, v in results.items())
+    return (result_str, result_latex)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Handler dispatch table
+# ─────────────────────────────────────────────────────────────────────────────
+
+_HANDLERS = {
+    "integrate":        _handle_integrate,
+    "differentiate":    _handle_differentiate,
+    "limit":            _handle_limit,
+    "solve":            _handle_solve,
+    "ode":              _handle_ode,
+    "series":           _handle_series,
+    "laplace":          _handle_laplace,
+    "inverse_laplace":  _handle_inverse_laplace,
+    "fourier":          _handle_fourier,
+    "simplify":         _handle_simplify,
+    "trig_simplify":    _handle_trig_simplify,
+    "factor":           _handle_factor,
+    "expand":           _handle_expand,
+    "partial_fraction": _handle_partial_fraction,
+    "eigenvalue":       _handle_eigenvalue,
+    "determinant":      _handle_determinant,
+    "inverse":          _handle_inverse,
+    "matrix_rank":      _handle_matrix_rank,
+    "matrix_trace":     _handle_matrix_trace,
+    "gcd":              _handle_gcd,
+    "lcm":              _handle_lcm,
+    "prime_factors":    _handle_prime_factors,
+    "modular":          _handle_modular,
+    "statistics":       _handle_statistics,
+    "factorial":        _handle_factorial,
+    "binomial":         _handle_binomial,
+    "permutation":      _handle_permutation,
+    "summation":        _handle_summation,
+    "product":          _handle_product,
+    "complex_ops":      _handle_complex_ops,
+}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Public interface
+# ─────────────────────────────────────────────────────────────────────────────
+
+def solve(user_input: str) -> Tuple[bool, str, str]:
+    """
+    Main entry point for the advanced math engine.
+
+    Args:
+        user_input: Natural language math query.
+
+    Returns:
+        (success, result_str, latex_str)
+        success    – True if SymPy computed an answer
+        result_str – Human-readable answer
+        latex_str  – LaTeX of the result
+    """
+    op = detect_advanced_operation(user_input)
+    if op is None:
+        return (False, "", "")
+
+    handler = _HANDLERS.get(op)
+    if handler is None:
+        return (False, f"Operation '{op}' recognised but not yet implemented.", "")
+
+    try:
+        result_str, latex_str = handler(user_input)
+        return (True, result_str, latex_str)
+    except Exception as exc:
+        return (False, f"Math engine error ({op}): {exc}", "")

conversation.txt

@@ -0,0 +1,23 @@
+# Conversation patterns for AnveshAI Edge Prototype
+# Format: PATTERN|||RESPONSE
+# Patterns are case-insensitive regex, separated from responses by |||
+
+hello|hi|hey|||Hello! I'm AnveshAI Edge. How can I help you today?
+how are you|how do you do|||I'm running smoothly and ready to assist you!
+what is your name|who are you|what are you|||I'm AnveshAI Edge Prototype, a local offline AI assistant built on a hierarchical modular architecture.
+what can you do|help me|what do you know|||I can answer knowledge questions, solve math problems, and chat with you — all locally without any internet connection! Type /help for commands.
+thank you|thanks|thank u|||You're welcome! Is there anything else I can help you with?
+bye|goodbye|see you|quit|exit|||Goodbye! Use /exit to close the session properly.
+good morning|||Good morning! Ready to assist you today.
+good evening|||Good evening! What can I help you with?
+good night|||Good night! Hope I was helpful today.
+who made you|who created you|who built you|||I was built as a demo of a hierarchical offline AI architecture. Designed to be modular and fully offline.
+are you smart|are you intelligent|||I'm a lightweight rule-based system — not as powerful as a large language model, but fast, private, and fully offline!
+what time is it|current time|||I don't have access to a clock, but you can check your system time easily.
+tell me a joke|joke|||Why do programmers prefer dark mode? Because light attracts bugs!
+what is ai|what is artificial intelligence|||Artificial Intelligence is the simulation of human intelligence in machines. Type 'knowledge: artificial intelligence' for a detailed explanation!
+interesting|cool|awesome|wow|||Glad you think so! What else would you like to explore?
+okay|ok|alright|||Sure! Let me know if there's anything I can help you with.
+yes|||Got it! What would you like to do next?
+no|||Understood. Feel free to ask me anything else.
+sorry|my bad|||No problem at all! How can I help you?

conversation_engine.py

@@ -0,0 +1,68 @@
+"""
+Conversation Engine — handles general chat using pattern-response pairs.
+
+How it works:
+    1. Loads 'conversation.txt' at startup.
+       Each non-comment line format: PATTERN|||RESPONSE
+    2. Tries to match user input against compiled regex patterns.
+    3. Returns (response, matched):
+         matched = True  → a pattern fired; use the response directly
+         matched = False → no match; caller should escalate to LLM fallback
+
+EXTENSION POINT: The respond() method can be replaced wholesale with an LLM
+call without touching any other module. Contract: (str) → (str, bool).
+"""
+
+import os
+import re
+from typing import List, Tuple
+
+
+CONVERSATION_FILE = os.path.join(os.path.dirname(__file__), "conversation.txt")
+
+
+def _load_patterns(filepath: str) -> List[Tuple[re.Pattern, str]]:
+    patterns: List[Tuple[re.Pattern, str]] = []
+    if not os.path.exists(filepath):
+        return patterns
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "|||" not in line:
+                continue
+            pattern_part, response_part = line.split("|||", 1)
+            pattern_str  = pattern_part.strip()
+            response_str = response_part.strip()
+            if not pattern_str or not response_str:
+                continue
+            try:
+                compiled = re.compile(pattern_str, re.IGNORECASE)
+                patterns.append((compiled, response_str))
+            except re.error:
+                continue
+    return patterns
+
+
+class ConversationEngine:
+    """Rule-based pattern-matching chat engine backed by conversation.txt."""
+
+    def __init__(self, conversation_file: str = CONVERSATION_FILE):
+        self.patterns = _load_patterns(conversation_file)
+
+    def respond(self, user_input: str) -> Tuple[str, bool]:
+        """
+        Match user input against stored patterns.
+
+        Returns:
+            (response, matched)
+            matched = True  → pattern found, response is ready to use
+            matched = False → no pattern matched; escalate to LLM
+        """
+        text = user_input.strip()
+        for pattern, response in self.patterns:
+            if pattern.search(text):
+                return (response, True)
+        # Signal: no rule matched — let the LLM handle it
+        return ("", False)

knowledge.txt

@@ -0,0 +1,29 @@
+Python is a high-level, interpreted programming language known for its readability and simplicity. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Python was created by Guido van Rossum and first released in 1991. It is widely used in web development, data science, artificial intelligence, and automation.
+
+Machine learning is a subset of artificial intelligence that enables systems to learn from data and improve their performance over time without being explicitly programmed. Common machine learning algorithms include linear regression, decision trees, neural networks, and support vector machines. Libraries like scikit-learn, TensorFlow, and PyTorch are widely used for machine learning in Python.
+
+Artificial intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think and learn. AI encompasses subfields such as machine learning, natural language processing, computer vision, and robotics. AI applications include virtual assistants, recommendation systems, autonomous vehicles, and medical diagnosis.
+
+Natural language processing (NLP) is a branch of AI that helps computers understand, interpret, and generate human language. Key NLP tasks include tokenization, sentiment analysis, named entity recognition, and machine translation. Popular NLP libraries include NLTK, spaCy, and Hugging Face Transformers.
+
+Deep learning is a subset of machine learning that uses neural networks with many layers (deep neural networks) to model complex patterns in data. It has achieved breakthrough performance in image recognition, speech recognition, and natural language understanding. Deep learning requires large datasets and significant computational resources.
+
+A database is an organized collection of structured information or data, typically stored electronically in a computer system. Databases are managed by database management systems (DBMS). Common types include relational databases (SQL) like MySQL, PostgreSQL, and SQLite, and non-relational databases (NoSQL) like MongoDB and Redis.
+
+The internet is a global network of interconnected computers that communicate using standardized protocols. It was developed in the late 1960s by ARPA (Advanced Research Projects Agency). The World Wide Web (WWW), invented by Tim Berners-Lee in 1989, is a service that runs on the internet and allows users to access websites using a browser.
+
+Cloud computing is the delivery of computing services including servers, storage, databases, networking, software, analytics, and intelligence over the internet to offer faster innovation, flexible resources, and economies of scale. Major cloud providers include Amazon Web Services (AWS), Microsoft Azure, and Google Cloud Platform.
+
+Linux is an open-source operating system kernel first released by Linus Torvalds in 1991. It forms the basis of many operating systems (distributions) such as Ubuntu, Fedora, and Debian. Linux is widely used in servers, supercomputers, Android devices, and embedded systems. It is known for its stability, security, and flexibility.
+
+Cybersecurity refers to the practice of protecting systems, networks, and programs from digital attacks. These attacks often aim to access, change, or destroy sensitive information, extort money, or interrupt normal business processes. Key concepts include encryption, firewalls, intrusion detection, and ethical hacking.
+
+Quantum computing is a type of computation that harnesses quantum mechanical phenomena such as superposition and entanglement. Unlike classical bits (0 or 1), quantum bits (qubits) can represent multiple states simultaneously. This allows quantum computers to solve certain problems exponentially faster than classical computers.
+
+Blockchain is a distributed ledger technology that records transactions across many computers so that the record cannot be altered retroactively. It was popularized by Bitcoin, the first decentralized cryptocurrency, created by the pseudonymous Satoshi Nakamoto in 2008. Blockchain is also used in smart contracts, supply chain management, and digital identity.
+
+An algorithm is a step-by-step procedure or formula for solving a problem. In computer science, algorithms are used to process data, perform calculations, and automate reasoning tasks. Common categories include sorting algorithms (quicksort, mergesort), search algorithms (binary search, BFS, DFS), and graph algorithms (Dijkstra, A*).
+
+Data structures are ways of organizing and storing data in a computer so that it can be accessed and modified efficiently. Common data structures include arrays, linked lists, stacks, queues, trees, heaps, hash tables, and graphs. Choosing the right data structure is fundamental to writing efficient algorithms.
+
+Version control is a system that records changes to files over time so you can recall specific versions later. Git is the most widely used version control system. Platforms like GitHub, GitLab, and Bitbucket host Git repositories and provide collaboration tools such as pull requests, issues, and CI/CD pipelines.

knowledge_engine.py

@@ -0,0 +1,122 @@
+"""
+Knowledge Engine — retrieves relevant information from a local knowledge base.
+
+How it works:
+    1. Loads 'knowledge.txt' at startup (one paragraph per blank-line block).
+    2. For a given query, scores each paragraph using keyword overlap.
+    3. Returns the highest-scoring paragraph + a boolean indicating confidence.
+       If confidence is low, the caller (main.py) will escalate to the LLM.
+
+This is intentionally lightweight and fully offline. In the future it can be
+swapped for a vector-based retrieval system (FAISS + sentence-transformers)
+without changing the rest of the architecture.
+"""
+
+import os
+import re
+from typing import List, Tuple
+
+
+KNOWLEDGE_FILE = os.path.join(os.path.dirname(__file__), "knowledge.txt")
+
+# A paragraph must score at least this much to be considered a real match.
+# Queries below this score are escalated to the LLM fallback.
+MIN_RELEVANCE_SCORE = 2
+
+STOP_WORDS = {
+    "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "shall",
+    "should", "may", "might", "must", "can", "could", "to", "of", "in",
+    "on", "at", "by", "for", "with", "about", "against", "between", "into",
+    "through", "during", "before", "after", "above", "below", "from",
+    "up", "down", "out", "off", "over", "under", "again", "and", "but",
+    "or", "nor", "so", "yet", "both", "either", "neither", "not", "no",
+    "what", "which", "who", "whom", "this", "that", "these", "those",
+    "i", "me", "my", "myself", "we", "our", "you", "your", "he", "she",
+    "it", "they", "them", "their", "tell", "explain", "describe", "give",
+    "me", "some", "information", "about",
+}
+
+
+def _load_paragraphs(filepath: str) -> List[str]:
+    if not os.path.exists(filepath):
+        return []
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+    raw = re.split(r"\n\s*\n", content.strip())
+    return [p.strip() for p in raw if p.strip()]
+
+
+def _tokenize(text: str) -> List[str]:
+    words = re.findall(r"\b[a-z]+\b", text.lower())
+    return [w for w in words if w not in STOP_WORDS and len(w) > 2]
+
+
+def _score_paragraph(query_tokens: List[str], paragraph: str) -> int:
+    para_lower = paragraph.lower()
+    score = 0
+    for token in query_tokens:
+        if re.search(r"\b" + re.escape(token) + r"\b", para_lower):
+            score += 2
+        elif token in para_lower:
+            score += 1
+    return score
+
+
+def _strip_knowledge_prefixes(text: str) -> str:
+    prefixes = [
+        "what is", "what are", "who is", "who are", "explain", "define",
+        "tell me about", "describe", "how does", "why is", "when was",
+        "where is", "history of", "meaning of", "knowledge:", "knowledge :",
+        "learn about", "facts about", "information about",
+    ]
+    lowered = text.lower().strip()
+    for prefix in prefixes:
+        if lowered.startswith(prefix):
+            return text[len(prefix):].strip()
+    return text
+
+
+class KnowledgeEngine:
+    """Local keyword-scored knowledge retrieval over knowledge.txt."""
+
+    def __init__(self, knowledge_file: str = KNOWLEDGE_FILE):
+        self.paragraphs: List[str] = _load_paragraphs(knowledge_file)
+        self._loaded = len(self.paragraphs) > 0
+
+    def is_loaded(self) -> bool:
+        return self._loaded
+
+    def query(self, user_input: str) -> Tuple[str, bool]:
+        """
+        Find the most relevant paragraph for the given query.
+
+        Returns:
+            (response, found)
+            found = True  → a high-confidence match was found in the KB
+            found = False → no confident match; caller should try the LLM
+        """
+        if not self._loaded:
+            return (
+                "Knowledge base unavailable. Ensure 'knowledge.txt' exists.",
+                False,
+            )
+
+        clean_query = _strip_knowledge_prefixes(user_input)
+        query_tokens = _tokenize(clean_query)
+
+        if not query_tokens:
+            return ("Could you rephrase? I couldn't parse the query.", False)
+
+        scored: List[Tuple[int, str]] = [
+            (_score_paragraph(query_tokens, para), para)
+            for para in self.paragraphs
+        ]
+
+        best_score, best_para = max(scored, key=lambda x: x[0])
+
+        if best_score < MIN_RELEVANCE_SCORE:
+            # Signal to caller: escalate to LLM
+            return ("", False)
+
+        return (best_para, True)

llm_engine.py

@@ -0,0 +1,158 @@
+"""
+LLM Engine — local Qwen2.5-0.5B-Instruct fallback via llama-cpp-python.
+
+This is the bottom layer of the AnveshAI hierarchy:
+
+    Math          →  math_engine         (instant, rule-based)
+    Knowledge     →  knowledge_engine    (keyword retrieval from knowledge.txt)
+      └─ no match →  LLMEngine.generate  (Qwen2.5-0.5B)
+    Conversation  →  conversation_engine (pattern matching from conversation.txt)
+      └─ no match →  LLMEngine.generate  (Qwen2.5-0.5B)
+
+Model: Qwen/Qwen2.5-0.5B-Instruct  (Q4_K_M GGUF, ~350 MB)
+    ─ Best-in-class quality at 0.5B parameters
+    ─ Runs entirely on CPU via llama.cpp
+    ─ Downloaded once into ~/.cache/huggingface/ on first use
+    ─ Loaded LAZILY: the model only loads when first needed,
+      keeping startup instant.
+"""
+
+MODEL_REPO   = "Qwen/Qwen2.5-0.5B-Instruct-GGUF"
+MODEL_FILE   = "qwen2.5-0.5b-instruct-q4_k_m.gguf"
+
+SYSTEM_PROMPT = (
+    "You are AnveshAI Edge, a helpful offline AI assistant. "
+    "Answer questions thoroughly and completely. Show full working steps "
+    "for math or technical questions. Do not repeat the question back. "
+    "If you are unsure about something, say so clearly."
+)
+
+MATH_SYSTEM_PROMPT = (
+    "You are a mathematics tutor. "
+    "You will be given a VERIFIED ANSWER computed by a symbolic engine. "
+    "That answer is 100% correct — do NOT change it, do NOT recompute it. "
+    "Your ONLY job is to explain, step by step, HOW a student would work through "
+    "the problem and arrive at that exact answer. "
+    "Every step must lead logically toward the verified answer. "
+    "State the verified answer word-for-word at the end of your explanation."
+)
+
+MAX_TOKENS  = 1024   # enough for detailed explanations and step-by-step answers
+TEMPERATURE = 0.7
+MATH_TEMPERATURE = 0.1   # near-deterministic for math explanations
+TOP_P       = 0.9
+N_CTX       = 16384  # match model's trained context (supports up to 32768)
+
+
+class LLMEngine:
+    """
+    Lazy-loading wrapper around Qwen2.5-0.5B-Instruct (GGUF via llama.cpp).
+
+    Usage:
+        engine = LLMEngine()
+        response = engine.generate("What is photosynthesis?")
+
+    The GGUF model is downloaded from HuggingFace on the first call to
+    generate() and cached locally. Every subsequent call reuses the
+    in-memory model — no re-loading.
+    """
+
+    def __init__(self) -> None:
+        self._llm   = None
+        self._loaded: bool = False
+        self._failed: bool = False
+        self._fail_reason: str = ""
+
+    def is_available(self) -> bool:
+        """True once the model has loaded without error."""
+        return self._loaded and not self._failed
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _load(self) -> None:
+        """Download (first run only) and load the GGUF model into memory."""
+        if self._loaded or self._failed:
+            return
+
+        try:
+            print(
+                f"\n  [LLM] Loading {MODEL_FILE} … "
+                "(first run downloads ~350 MB, then cached locally)",
+                flush=True,
+            )
+
+            from llama_cpp import Llama
+
+            self._llm = Llama.from_pretrained(
+                repo_id=MODEL_REPO,
+                filename=MODEL_FILE,
+                n_ctx=N_CTX,
+                n_threads=4,   # use up to 4 CPU threads
+                verbose=False,
+            )
+
+            self._loaded = True
+            print("  [LLM] Qwen2.5-0.5B-Instruct ready\n", flush=True)
+
+        except Exception as exc:
+            self._failed = True
+            self._fail_reason = str(exc)
+            print(f"  [LLM] Failed to load: {exc}\n", flush=True)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def generate(
+        self,
+        user_input: str,
+        context: str = "",
+        system_prompt: str = "",
+        temperature: float = TEMPERATURE,
+    ) -> str:
+        """
+        Generate a response using the local LLM.
+
+        Args:
+            user_input    : The user's message or question.
+            context       : Optional retrieved text to inject as background.
+            system_prompt : Override the default system prompt (e.g. for math).
+            temperature   : Sampling temperature; use low values for math.
+
+        Returns:
+            The model's reply as a plain string.
+        """
+        self._load()
+
+        if self._failed:
+            return (
+                "The local LLM is currently unavailable "
+                f"({self._fail_reason}). "
+                "Ensure 'llama-cpp-python' is installed and the model "
+                "could be downloaded."
+            )
+
+        try:
+            system_content = system_prompt if system_prompt else SYSTEM_PROMPT
+            if context:
+                system_content += f"\n\nRelevant background:\n{context}"
+
+            messages = [
+                {"role": "system", "content": system_content},
+                {"role": "user",   "content": user_input},
+            ]
+
+            output = self._llm.create_chat_completion(
+                messages=messages,
+                max_tokens=MAX_TOKENS,
+                temperature=temperature,
+                top_p=TOP_P,
+            )
+
+            response: str = output["choices"][0]["message"]["content"]
+            return response.strip()
+
+        except Exception as exc:
+            return f"LLM generation error: {exc}"

main.py

@@ -0,0 +1,323 @@
+"""
+AnveshAI Edge Prototype
+=======================
+Terminal-based offline AI assistant — hierarchical modular architecture
+with chain-of-thought (CoT) reasoning.
+
+Routing & reasoning chain:
+    /commands        →  inline handler                       (instant)
+    Plain arithmetic →  math_engine                         (instant, AST-based)
+    Advanced math    →  ReasoningEngine.analyze()           (problem decomposition)
+                          └─ advanced_math_engine           (SymPy symbolic)
+                               └─ ReasoningEngine.build_math_prompt()
+                                    → LLM step-by-step explanation
+    Knowledge query  →  ReasoningEngine.analyze()           (CoT planning)
+                          └─ knowledge_engine               (local KB)
+                               ├─ match found → return KB paragraph
+                               └─ no match   → ReasoningEngine.build_general_prompt()
+                                               → LLM structured answer
+    Conversation     →  conversation_engine                 (pattern rules)
+                          └─ no pattern → ReasoningEngine.build_general_prompt()
+                                           → LLM structured answer
+
+Commands:
+    /help    → list commands
+    /history → last 10 interactions
+    /exit    → quit
+"""
+
+import sys
+
+# ── Optional colour support ───────────────────────────────────────────────────
+try:
+    from colorama import init as colorama_init, Fore, Style
+    colorama_init(autoreset=True)
+except ImportError:
+    class _NoColor:
+        def __getattr__(self, _): return ""
+    Fore = Style = _NoColor()
+
+# ── Module imports ────────────────────────────────────────────────────────────
+from router                import classify_intent
+from math_engine           import evaluate as math_evaluate
+from advanced_math_engine  import solve as advanced_math_solve
+from knowledge_engine      import KnowledgeEngine
+from conversation_engine   import ConversationEngine
+from llm_engine            import LLMEngine, MATH_SYSTEM_PROMPT, MATH_TEMPERATURE
+from reasoning_engine      import ReasoningEngine
+from memory                import initialize_db, save_interaction, format_history
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+BANNER = r"""
+╔══════════════════════════════════════════════════════╗
+║     ___                    __   ___   ____           ║
+║    / _ | ___ _  _____ ___ / /  / _ | /  _/           ║
+║   / __ |/ _ \ |/ / -_|_-</ _ \/ __ |_/ /             ║
+║  /_/ |_/_//_/___/\__/___/_//_/_/ |_/___/  EDGE       ║
+║                                                      ║
+╚══════════════════════════════════════════════════════╝
+"""
+
+HELP_TEXT = """
+  Available commands:
+    /help     — show this help message
+    /history  — display last 10 conversation entries
+    /exit     — quit AnveshAI Edge
+
+  How to use:
+    • Advanced math  →  symbolic engine computes the EXACT answer,
+                        LLM explains step-by-step working
+
+      Calculus:
+        "integrate x^2 sin(x)"
+        "definite integral of x^2 from 0 to 3"
+        "derivative of x^3 + 2x"
+        "second derivative of sin(x) * e^x"
+        "limit of sin(x)/x as x approaches 0"
+
+      Algebra & equations:
+        "solve x^2 - 5x + 6 = 0"
+        "solve 2x + 3 = 7"
+
+      Differential equations:
+        "solve differential equation y'' + y = 0"
+        "solve ode dy/dx = y"
+
+      Series & transforms:
+        "taylor series of e^x around 0 order 6"
+        "laplace transform of sin(t)"
+        "inverse laplace of 1/(s^2 + 1)"
+        "fourier transform of exp(-x^2)"
+
+      Matrices:
+        "determinant of [[1,2],[3,4]]"
+        "inverse matrix [[2,1],[5,3]]"
+        "eigenvalue [[4,1],[2,3]]"
+        "rank of matrix [[1,2,3],[4,5,6]]"
+
+      Symbolic manipulation:
+        "factor x^3 - 8"
+        "simplify (x^2 - 1)/(x - 1)"
+        "expand (x + y)^4"
+        "partial fraction 1/(x^2 - 1)"
+
+      Number theory:
+        "gcd of 48 and 18"
+        "lcm of 12 and 15"
+        "prime factorization of 360"
+        "17 mod 5"
+        "modular inverse of 3 mod 7"
+
+      Statistics:
+        "mean of 2, 4, 6, 8, 10"
+        "standard deviation of 1, 2, 3, 4, 5"
+
+      Combinatorics:
+        "factorial of 10"
+        "binomial coefficient 10 choose 3"
+        "permutation 6 P 2"
+
+      Summations:
+        "sum of k^2 for k from 1 to 10"
+        "summation of 1/n^2 for n from 1 to infinity"
+
+      Complex numbers:
+        "real part of 3 + 4*I"
+        "modulus of 3 + 4*I"
+
+    • Arithmetic     →  computed instantly
+      e.g.  "2 + 3 * (4 ^ 2)"
+
+    • Knowledge      →  local KB first, then LLM
+      e.g.  "What is quantum computing?"
+
+    • Chat           →  pattern rules, then LLM
+      e.g.  "Hello!"
+"""
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Terminal helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _print(text: str, color: str = "") -> None:
+    print(f"{color}{text}{Style.RESET_ALL}" if color else text)
+
+
+def _prompt() -> str:
+    try:
+        return input(f"\n{Fore.CYAN}You{Style.RESET_ALL} › ").strip()
+    except (EOFError, KeyboardInterrupt):
+        return "/exit"
+
+
+def _respond(label: str, text: str) -> None:
+    print(
+        f"\n{Fore.GREEN}AnveshAI{Style.RESET_ALL} "
+        f"[{Fore.YELLOW}{label}{Style.RESET_ALL}] › {text}"
+    )
+
+
+def _system(text: str) -> None:
+    print(f"{Fore.MAGENTA}  {text}{Style.RESET_ALL}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Response Composer
+# ─────────────────────────────────────────────────────────────────────────────
+
+def compose_response(
+    user_input: str,
+    intent: str,
+    knowledge_engine: KnowledgeEngine,
+    conversation_engine: ConversationEngine,
+    llm_engine: LLMEngine,
+    reasoning_engine: ReasoningEngine,
+) -> tuple[str, str]:
+    """
+    Route input through the full hierarchy with chain-of-thought reasoning.
+    Returns (label, response_text).
+
+    Labels:
+        Math             – plain arithmetic result (instant)
+        AdvMath+CoT+LLM  – SymPy computed, reasoning planned, LLM explained
+        AdvMath+CoT      – SymPy computed, reasoning-guided LLM fallback
+        Knowledge        – local KB answered
+        LLM+CoT-KB       – KB miss; reasoning-guided LLM answered
+        Chat             – conversation pattern matched
+        LLM+CoT          – reasoning-guided LLM answered
+    """
+
+    # ── Simple arithmetic ─────────────────────────────────────────────────────
+    if intent == "math":
+        return "Math", math_evaluate(user_input)
+
+    # ── Advanced math ─────────────────────────────────────────────────────────
+    if intent == "advanced_math":
+        success, result_str, _latex = advanced_math_solve(user_input)
+
+        if success:
+            _system(f"SymPy → {result_str}")
+            _system("Reasoning engine: decomposing problem…")
+            plan = reasoning_engine.analyze(
+                user_input, intent, has_symbolic_result=True
+            )
+            _system(plan.summary())
+            if plan.warnings:
+                for w in plan.warnings:
+                    _system(f"  ⚠  {w}")
+            _system("Building chain-of-thought prompt → LLM…")
+            prompt = reasoning_engine.build_math_prompt(user_input, result_str, plan)
+            explanation = llm_engine.generate(
+                prompt,
+                system_prompt=MATH_SYSTEM_PROMPT,
+                temperature=MATH_TEMPERATURE,
+            )
+            full_response = (
+                f"{result_str}\n\n"
+                f"[Reasoning: {plan.problem_type} | {plan.strategy[:60]}]\n\n"
+                f"{explanation}"
+            )
+            return "AdvMath+CoT+LLM", full_response
+
+        else:
+            _system(f"SymPy error: {result_str}")
+            _system("Reasoning engine: building fallback chain-of-thought…")
+            plan = reasoning_engine.analyze(user_input, intent)
+            _system(plan.summary())
+            prompt = reasoning_engine.build_math_fallback_prompt(
+                user_input, plan, error_context=result_str
+            )
+            llm_response = llm_engine.generate(prompt)
+            return "AdvMath+CoT", llm_response
+
+    # ── Knowledge ─────────────────────────────��───────────────────────────────
+    if intent == "knowledge":
+        kb_response, kb_found = knowledge_engine.query(user_input)
+        if kb_found:
+            return "Knowledge", kb_response
+
+        _system("KB: no match — reasoning engine + LLM…")
+        plan = reasoning_engine.analyze(user_input, intent)
+        _system(plan.summary())
+        prompt = reasoning_engine.build_general_prompt(
+            user_input, intent, kb_response, plan
+        )
+        return "LLM+CoT-KB", llm_engine.generate(prompt)
+
+    # ── Conversation ──────────────────────────────────────────────────────────
+    chat_response, pattern_matched = conversation_engine.respond(user_input)
+    if pattern_matched:
+        return "Chat", chat_response
+
+    _system("No pattern match — reasoning engine + LLM…")
+    plan = reasoning_engine.analyze(user_input, intent)
+    _system(plan.summary())
+    prompt = reasoning_engine.build_general_prompt(user_input, intent, "", plan)
+    return "LLM+CoT", llm_engine.generate(prompt)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main loop
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    _print(BANNER, Fore.CYAN)
+    _system("Initialising modules…")
+
+    initialize_db()
+    _system("✔  Memory (SQLite) ready")
+
+    knowledge_engine    = KnowledgeEngine()
+    _system("✔  Knowledge base loaded" if knowledge_engine.is_loaded() else "⚠  knowledge.txt not found")
+
+    conversation_engine = ConversationEngine()
+    _system("✔  Conversation engine ready")
+    _system("✔  Math engine ready (AST safe-eval)")
+    _system("✔  Advanced math engine ready (SymPy — 31+ operations)")
+    _system("✔  Reasoning engine ready (chain-of-thought + CoT planning)")
+    _system("✔  Intent router ready")
+
+    llm_engine      = LLMEngine()
+    reasoning_eng   = ReasoningEngine()
+    _system("✔  LLM engine ready (Qwen2.5-0.5B loads on first use)")
+
+    _print(f"\n{Fore.WHITE}Type /help for commands or just start chatting!{Style.RESET_ALL}")
+
+    while True:
+        user_input = _prompt()
+        if not user_input:
+            continue
+
+        intent = classify_intent(user_input)
+
+        # ── System commands ───────────────────────────────────────────────────
+        if intent == "system":
+            cmd = user_input.lower().split()[0]
+            if cmd == "/exit":
+                _print(f"\n{Fore.CYAN}Goodbye! Session closed.{Style.RESET_ALL}")
+                sys.exit(0)
+            elif cmd == "/history":
+                _print(f"\n{Fore.YELLOW}── Conversation History ─────────────────────{Style.RESET_ALL}")
+                _print(format_history())
+                _print(f"{Fore.YELLOW}─────────────────────────────────────────────{Style.RESET_ALL}")
+            elif cmd == "/help":
+                _print(f"\n{Fore.YELLOW}── Help ──────────────────────────────────────{Style.RESET_ALL}")
+                _print(HELP_TEXT)
+                _print(f"{Fore.YELLOW}─────────────────────────────────────────────{Style.RESET_ALL}")
+            else:
+                _respond("System", f"Unknown command '{user_input}'. Type /help.")
+            continue
+
+        # ── Compose response ──────────────────────────────────────────────────
+        label, response = compose_response(
+            user_input, intent, knowledge_engine,
+            conversation_engine, llm_engine, reasoning_eng
+        )
+        _respond(label, response)
+        save_interaction(user_input, response)
+
+
+if __name__ == "__main__":
+    main()

math_engine.py

@@ -0,0 +1,148 @@
+"""
+Math Engine — safely evaluates mathematical expressions.
+
+Supported operations:
+    +  Addition
+    -  Subtraction
+    *  Multiplication
+    /  Division
+    %  Modulo
+    ^  Exponentiation (converted to **)
+    () Parentheses for grouping
+
+Uses a whitelist-based safe evaluator to avoid arbitrary code execution.
+"""
+
+import re
+import ast
+import operator
+
+
+# Allowed AST node types for safe evaluation
+ALLOWED_NODES = (
+    ast.Expression,
+    ast.BinOp,
+    ast.UnaryOp,
+    ast.Constant,
+    ast.Add,
+    ast.Sub,
+    ast.Mult,
+    ast.Div,
+    ast.Mod,
+    ast.Pow,
+    ast.USub,    # unary minus, e.g. -5
+    ast.UAdd,    # unary plus, e.g. +5
+)
+
+# Mapping AST operators to Python functions
+OPERATORS = {
+    ast.Add:  operator.add,
+    ast.Sub:  operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div:  operator.truediv,
+    ast.Mod:  operator.mod,
+    ast.Pow:  operator.pow,
+    ast.USub: operator.neg,
+    ast.UAdd: operator.pos,
+}
+
+# Prefixes the user might add before the expression
+STRIP_PREFIXES = (
+    "calculate", "compute", "evaluate", "solve",
+    "what is", "what's",
+)
+
+
+def extract_expression(user_input: str) -> str:
+    """
+    Strip any natural-language prefixes to get the raw math expression.
+    Also converts '^' to '**' for exponentiation.
+    """
+    text = user_input.strip()
+    lowered = text.lower()
+
+    for prefix in STRIP_PREFIXES:
+        if lowered.startswith(prefix):
+            text = text[len(prefix):].strip()
+            break
+
+    # Replace caret with Python exponentiation operator
+    text = text.replace("^", "**")
+
+    return text
+
+
+def safe_eval(expression: str) -> float:
+    """
+    Safely evaluate a mathematical expression string.
+
+    Raises ValueError if the expression is invalid or contains disallowed
+    operations.
+    """
+    try:
+        tree = ast.parse(expression, mode="eval")
+    except SyntaxError:
+        raise ValueError(f"Invalid mathematical expression: '{expression}'")
+
+    # Validate every node in the AST
+    for node in ast.walk(tree):
+        if not isinstance(node, ALLOWED_NODES):
+            raise ValueError(
+                f"Unsafe or unsupported operation detected: {type(node).__name__}"
+            )
+
+    return _eval_node(tree.body)
+
+
+def _eval_node(node: ast.AST) -> float:
+    """Recursively evaluate an AST node."""
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, (int, float)):
+            return node.value
+        raise ValueError(f"Unsupported constant type: {type(node.value)}")
+
+    if isinstance(node, ast.BinOp):
+        left = _eval_node(node.left)
+        right = _eval_node(node.right)
+        op_func = OPERATORS.get(type(node.op))
+        if op_func is None:
+            raise ValueError(f"Unsupported binary operator: {type(node.op).__name__}")
+        if isinstance(node.op, ast.Div) and right == 0:
+            raise ValueError("Division by zero is not allowed.")
+        return op_func(left, right)
+
+    if isinstance(node, ast.UnaryOp):
+        operand = _eval_node(node.operand)
+        op_func = OPERATORS.get(type(node.op))
+        if op_func is None:
+            raise ValueError(f"Unsupported unary operator: {type(node.op).__name__}")
+        return op_func(operand)
+
+    raise ValueError(f"Unsupported AST node: {type(node).__name__}")
+
+
+def evaluate(user_input: str) -> str:
+    """
+    Main entry point: extract the expression, evaluate it, and return
+    a formatted result string.
+    """
+    expression = extract_expression(user_input)
+
+    if not expression:
+        return "Please provide a mathematical expression to evaluate."
+
+    try:
+        result = safe_eval(expression)
+
+        # Format: show integer if result is whole, else show decimal
+        if isinstance(result, float) and result.is_integer():
+            formatted = str(int(result))
+        else:
+            formatted = f"{result:.6g}"  # up to 6 significant figures
+
+        return f"The result of {expression} = {formatted}"
+
+    except ValueError as e:
+        return f"Math error: {e}"
+    except Exception as e:
+        return f"Unexpected error evaluating expression: {e}"

memory.py

@@ -0,0 +1,99 @@
+"""
+Memory System — stores and retrieves conversation history using SQLite.
+
+Schema:
+    conversations (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp   TEXT    NOT NULL,  -- ISO 8601 format
+        user_input  TEXT    NOT NULL,
+        response    TEXT    NOT NULL
+    )
+
+Commands:
+    /history   → display the last 10 interactions
+"""
+
+import sqlite3
+import os
+from datetime import datetime
+from typing import List, Tuple
+
+
+DB_PATH = os.path.join(os.path.dirname(__file__), "anveshai_memory.db")
+HISTORY_LIMIT = 10
+
+
+def _get_connection() -> sqlite3.Connection:
+    """Open and return a SQLite database connection."""
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def initialize_db() -> None:
+    """
+    Create the conversations table if it does not already exist.
+    Called once at startup.
+    """
+    with _get_connection() as conn:
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS conversations (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp   TEXT    NOT NULL,
+                user_input  TEXT    NOT NULL,
+                response    TEXT    NOT NULL
+            )
+        """)
+        conn.commit()
+
+
+def save_interaction(user_input: str, response: str) -> None:
+    """
+    Persist a single interaction (user input + assistant response) to the DB.
+    """
+    timestamp = datetime.now().isoformat(sep=" ", timespec="seconds")
+    with _get_connection() as conn:
+        conn.execute(
+            "INSERT INTO conversations (timestamp, user_input, response) VALUES (?, ?, ?)",
+            (timestamp, user_input, response),
+        )
+        conn.commit()
+
+
+def get_recent_history(limit: int = HISTORY_LIMIT) -> List[sqlite3.Row]:
+    """
+    Retrieve the most recent `limit` interactions, ordered oldest-first.
+    """
+    with _get_connection() as conn:
+        cursor = conn.execute(
+            """
+            SELECT id, timestamp, user_input, response
+            FROM conversations
+            ORDER BY id DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+        rows = cursor.fetchall()
+    # Reverse so oldest appears first
+    return list(reversed(rows))
+
+
+def format_history() -> str:
+    """
+    Return a formatted string of the last HISTORY_LIMIT interactions.
+    Returns a notice if there's nothing to show.
+    """
+    rows = get_recent_history()
+
+    if not rows:
+        return "No conversation history yet."
+
+    lines = [f"  Last {len(rows)} interaction(s):\n"]
+    for row in rows:
+        lines.append(f"  [{row['timestamp']}]")
+        lines.append(f"  You      : {row['user_input']}")
+        lines.append(f"  AnveshAI : {row['response']}")
+        lines.append("")  # blank line between entries
+
+    return "\n".join(lines).rstrip()

reasoning_engine.py

@@ -0,0 +1,599 @@
+"""
+Advanced Reasoning Engine — Chain-of-Thought (CoT) reasoning layer.
+
+Sits between the intent router and the LLM / specialist engines.
+Provides structured, multi-step reasoning for every response:
+
+    Stage 1 — Problem Analysis
+        · Identify problem type, domain, and sub-questions
+        · Detect ambiguity or missing information
+        · Choose the optimal resolution strategy
+
+    Stage 2 — Chain-of-Thought Planning
+        · Decompose complex problems into ordered sub-steps
+        · Identify dependencies between sub-steps
+        · Estimate difficulty and required knowledge
+
+    Stage 3 — Verification & Confidence
+        · Cross-check reasoning against known constraints
+        · Assign confidence level (HIGH / MEDIUM / LOW)
+        · Flag any assumptions made
+
+    Stage 4 — Response Synthesis
+        · Compose final LLM prompt that enforces the reasoning trace
+        · Force the LLM to follow the plan and not deviate
+
+For advanced math the engine adds a symbolic pre-analysis step:
+    · Identify operation type and variable structure
+    · Reason about the expected form of the answer
+    · Verify the SymPy result makes mathematical sense
+
+Usage:
+    from reasoning_engine import ReasoningEngine
+    re = ReasoningEngine()
+    plan = re.analyze("integrate x^2 sin(x)", intent="advanced_math")
+    prompt = re.build_math_prompt(user_input, sympy_result, plan)
+    prompt_gen = re.build_general_prompt(user_input, intent, context, plan)
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Data structures
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class ReasoningPlan:
+    """Structured reasoning plan produced by the engine."""
+    problem_type:   str                = "unknown"
+    domain:         str                = "general"
+    sub_problems:   list[str]          = field(default_factory=list)
+    strategy:       str                = ""
+    expected_form:  str                = ""
+    assumptions:    list[str]          = field(default_factory=list)
+    confidence:     str                = "MEDIUM"      # HIGH / MEDIUM / LOW
+    reasoning_steps: list[str]         = field(default_factory=list)
+    warnings:       list[str]          = field(default_factory=list)
+
+    def summary(self) -> str:
+        """One-line summary for console display."""
+        return (
+            f"[Reasoning] domain={self.domain} | strategy={self.strategy[:60]} "
+            f"| confidence={self.confidence}"
+        )
+
+    def full_trace(self) -> str:
+        """Full reasoning trace as a numbered list."""
+        lines = [f"Problem type: {self.problem_type}", f"Domain: {self.domain}"]
+        if self.sub_problems:
+            lines.append("Sub-problems:")
+            for i, sp in enumerate(self.sub_problems, 1):
+                lines.append(f"  {i}. {sp}")
+        lines.append(f"Strategy: {self.strategy}")
+        if self.expected_form:
+            lines.append(f"Expected answer form: {self.expected_form}")
+        if self.assumptions:
+            lines.append("Assumptions: " + "; ".join(self.assumptions))
+        if self.warnings:
+            lines.append("Warnings: " + "; ".join(self.warnings))
+        lines.append(f"Confidence: {self.confidence}")
+        return "\n".join(lines)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Domain / problem-type classifiers
+# ─────────────────────────────────────────────────────────────────────────────
+
+_DOMAIN_HINTS: dict[str, list[str]] = {
+    "calculus": [
+        "integrate", "integral", "derivative", "differentiate",
+        "d/dx", "limit", "lim", "antiderivative",
+    ],
+    "algebra": [
+        "solve", "factor", "expand", "simplify", "roots", "zeros",
+        "equation", "polynomial", "quadratic",
+    ],
+    "linear_algebra": [
+        "matrix", "eigenvalue", "eigenvector", "determinant",
+        "inverse", "rank", "trace", "vector", "dot product", "cross product",
+    ],
+    "differential_equations": [
+        "differential equation", "ode", "dy/dx", "y''", "y'", "dsolve",
+    ],
+    "transforms": [
+        "laplace", "fourier", "z-transform", "inverse laplace",
+    ],
+    "series": [
+        "taylor", "maclaurin", "power series", "series expansion",
+    ],
+    "number_theory": [
+        "prime", "gcd", "lcm", "modular", "mod ", "divisible",
+        "factorization", "congruence",
+    ],
+    "statistics": [
+        "mean", "median", "mode", "variance", "standard deviation",
+        "average", "probability", "distribution",
+    ],
+    "combinatorics": [
+        "factorial", "binomial", "permutation", "combination", "choose",
+        "nCr", "nPr",
+    ],
+    "complex_analysis": [
+        "complex", "imaginary", "real part", "modulus", "argument",
+        "conjugate", "polar form",
+    ],
+    "physics": [
+        "velocity", "acceleration", "force", "energy", "momentum",
+        "electric", "magnetic", "quantum", "wave", "frequency",
+    ],
+    "computer_science": [
+        "algorithm", "complexity", "big o", "sorting", "graph",
+        "recursion", "dynamic programming",
+    ],
+}
+
+_PROBLEM_TYPE_PATTERNS: list[tuple[str, str]] = [
+    # Highest-priority: detect before generic "solve" or "equation"
+    (r'\bdifferential\s+equation\b|\bode\b|\bdsolve\b', "ode_solving"),
+    (r'\bintegrate\b|\bintegral\b|\bantiderivative\b', "integration"),
+    (r'\bderivative\b|\bdifferentiate\b|\bd/d[a-z]\b', "differentiation"),
+    (r'\blimit\b|\blim\s', "limit_evaluation"),
+    (r'\beigenvalue\b|\beigenvector\b', "matrix_operation"),
+    (r'\bdeterminant\b|\bdet\b|\binverse\s+matrix\b|\bmatrix\s+rank\b|\bmatrix\s+trace\b', "matrix_operation"),
+    (r'\btaylor\b|\bmaclaurin\b|\bseries\s+expansion\b|\bpower\s+series\b', "series_expansion"),
+    (r'\blaplace\s+transform\b|\blaplace\s+of\b', "laplace_transform"),
+    (r'\bfourier\s+transform\b|\bfourier\s+of\b', "fourier_transform"),
+    (r'\bprime\s+factor|\bgcd\b|\blcm\b|\bmod\b|\bmodular\b', "number_theory"),
+    (r'\bfactorial\b|\bbinomial\s+coeff|\bpermutation\b|\bnCr\b|\bnPr\b', "combinatorics"),
+    (r'\bsum\s+of\b|\bsummation\b|\bsum\b.*\bfrom\b', "summation"),
+    (r'\bmean\b|\bmedian\b|\bvariance\b|\bstandard\s+deviation\b|\baverage\b', "statistical_analysis"),
+    (r'\bcomplex\s+number\b|\bimaginary\s+part\b|\breal\s+part\b|\bmodulus\s+of\b|\bargument\s+of\b', "complex_number"),
+    (r'\bfactor\b|\bfactorise\b|\bfactorize\b', "factorization"),
+    (r'\bexpand\b', "algebraic_expansion"),
+    (r'\bsimplify\b', "simplification"),
+    (r'\bsolve\b|\broots?\s+of\b|\bzeros?\s+of\b', "equation_solving"),
+    (r'\bwhat\s+is\b|\bwho\s+is\b|\bexplain\b|\bdefine\b', "knowledge_retrieval"),
+    (r'\bhow\s+to\b|\bhow\s+does\b', "procedural_knowledge"),
+    (r'\bwhy\b', "explanatory_reasoning"),
+    (r'\bcompare\b|\bdifference\s+between\b', "comparative_analysis"),
+]
+
+_STRATEGIES: dict[str, str] = {
+    "integration":        "Apply integration rules (u-sub, IBP, trig-sub, or direct antiderivative)",
+    "differentiation":    "Apply chain rule, product rule, quotient rule, or basic derivative rules",
+    "limit_evaluation":   "Apply L'Hôpital's rule, algebraic manipulation, or squeeze theorem",
+    "equation_solving":   "Factor, use quadratic formula, or numerical methods as needed",
+    "factorization":      "Factor out GCF, then use special patterns (difference of squares, sum/difference of cubes)",
+    "algebraic_expansion":"Apply binomial theorem or FOIL method for products",
+    "simplification":     "Cancel common factors, apply trig/logarithm identities, or algebraic reduction",
+    "matrix_operation":   "Apply matrix algorithms: cofactor expansion (det), row reduction (rank/inverse), characteristic polynomial (eigenvalues)",
+    "ode_solving":        "Classify ODE (linear/separable/exact/homogeneous) and apply corresponding solution method",
+    "series_expansion":   "Compute Taylor/Maclaurin coefficients using repeated differentiation",
+    "laplace_transform":  "Apply Laplace transform table entries and linearity",
+    "fourier_transform":  "Apply Fourier transform definition and standard pairs",
+    "number_theory":      "Apply Euclidean algorithm (GCD/LCM) or prime factorization via trial division",
+    "statistical_analysis": "Compute descriptive statistics: mean, variance (E[(X-μ)²]), std deviation",
+    "combinatorics":      "Apply counting principles: factorial, binomial theorem, or permutation formulas",
+    "complex_number":     "Use Cartesian/polar form of complex numbers and their properties",
+    "knowledge_retrieval": "Retrieve and synthesize relevant factual information",
+    "procedural_knowledge": "Provide a clear step-by-step explanation of the procedure",
+    "explanatory_reasoning": "Reason about causes, mechanisms, or justifications",
+    "comparative_analysis": "Identify key dimensions of comparison and contrast each one",
+    "unknown":            "Analyze the problem and apply the most relevant reasoning approach",
+}
+
+_EXPECTED_FORMS: dict[str, str] = {
+    "integration":        "A symbolic function + constant of integration C (indefinite) or a real number (definite)",
+    "differentiation":    "A symbolic expression of the same or lower degree",
+    "limit_evaluation":   "A real number, ∞, -∞, or 'does not exist'",
+    "equation_solving":   "One or more numerical or symbolic values for the unknown",
+    "factorization":      "A product of irreducible factors",
+    "series_expansion":   "A polynomial in x up to the given order, plus O(x^n) remainder",
+    "matrix_operation":   "A scalar (det/rank/trace) or matrix (inverse/eigenvectors)",
+    "ode_solving":        "A function y(x) with integration constants C1, C2, …",
+    "laplace_transform":  "A rational or transcendental function of s",
+    "fourier_transform":  "A function of the frequency variable k",
+    "statistical_analysis": "Real-valued descriptive statistics (mean, variance, std)",
+    "combinatorics":      "A non-negative integer",
+}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Multi-hop decomposer
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _decompose(user_input: str, problem_type: str, intent: str) -> list[str]:
+    """Break the problem into an ordered list of sub-problems / reasoning steps."""
+    lowered = user_input.lower()
+
+    # Math decompositions
+    if problem_type == "integration":
+        steps = ["Identify the integrand and the variable of integration"]
+        if "from" in lowered and "to" in lowered:
+            steps.append("Confirm the integration limits (lower and upper bounds)")
+        steps += [
+            "Check whether u-substitution, integration by parts, or a standard form applies",
+            "Compute the antiderivative step by step",
+            "Apply the Fundamental Theorem of Calculus if limits are given",
+            "Simplify the result and add C for indefinite integrals",
+        ]
+        return steps
+
+    if problem_type == "differentiation":
+        steps = ["Identify the function and the differentiation variable"]
+        if "second" in lowered or "third" in lowered or "2nd" in lowered or "3rd" in lowered:
+            steps.append("Determine the required order of differentiation")
+        steps += [
+            "Identify which rules apply (chain rule, product rule, quotient rule)",
+            "Differentiate term by term",
+            "Simplify the derivative expression",
+        ]
+        return steps
+
+    if problem_type == "limit_evaluation":
+        return [
+            "Identify the function and the point of approach",
+            "Check for direct substitution; if it gives 0/0 or ∞/∞, apply L'Hôpital's rule",
+            "Alternatively, try algebraic simplification or known limit results",
+            "Evaluate the limit or determine if it diverges",
+        ]
+
+    if problem_type == "equation_solving":
+        steps = ["Identify the type of equation (linear, quadratic, polynomial, transcendental)"]
+        if "=" in user_input:
+            steps.append("Rearrange so one side is 0 (or use direct substitution for LHS=RHS)")
+        steps += [
+            "Choose the solution method: factoring, quadratic formula, or numeric methods",
+            "Find all solutions in the required domain",
+            "Verify each solution satisfies the original equation",
+        ]
+        return steps
+
+    if problem_type == "ode_solving":
+        return [
+            "Classify the ODE: order, linearity, and special form",
+            "For 1st order: check separable, linear (integrating factor), exact",
+            "For 2nd order: find the characteristic equation and its roots",
+            "Write the general solution with arbitrary constants C1, C2, …",
+            "Apply initial conditions if provided to find particular solution",
+        ]
+
+    if problem_type == "matrix_operation":
+        steps = ["Identify the matrix dimensions and operation required"]
+        if "eigenvalue" in lowered:
+            steps += [
+                "Form the characteristic polynomial det(A - λI) = 0",
+                "Solve for eigenvalues λ",
+                "For each eigenvalue, solve (A - λI)v = 0 for eigenvectors",
+            ]
+        elif "determinant" in lowered or "det" in lowered:
+            steps += [
+                "Choose expansion method: cofactor expansion or row reduction",
+                "Compute the determinant",
+            ]
+        elif "inverse" in lowered:
+            steps += [
+                "Augment the matrix with the identity: [A | I]",
+                "Row-reduce to obtain [I | A⁻¹]",
+            ]
+        return steps
+
+    if problem_type == "series_expansion":
+        return [
+            "Identify the function and expansion point",
+            "Compute successive derivatives at the expansion point",
+            "Form the Taylor/Maclaurin series coefficients: f^(n)(a) / n!",
+            "Write the series up to the required order",
+            "Identify the pattern or general term if possible",
+        ]
+
+    if problem_type == "laplace_transform":
+        return [
+            "Express the function in terms of known Laplace pairs",
+            "Apply linearity of the Laplace transform",
+            "Use standard table entries or direct computation",
+            "Simplify the result in the s-domain",
+        ]
+
+    # Knowledge / reasoning decompositions
+    if problem_type == "knowledge_retrieval":
+        return [
+            "Identify the core concept being asked about",
+            "Recall the definition and key properties",
+            "Provide relevant examples or applications",
+            "Connect to related concepts if helpful",
+        ]
+
+    if problem_type == "explanatory_reasoning":
+        return [
+            "Identify the phenomenon / concept requiring explanation",
+            "Determine the causal chain or mechanism",
+            "State any assumptions or simplifications",
+            "Synthesise a clear, evidence-based explanation",
+        ]
+
+    if problem_type == "comparative_analysis":
+        return [
+            "Identify what is being compared",
+            "List key dimensions of comparison",
+            "Analyse each dimension for both subjects",
+            "Summarise similarities and differences",
+        ]
+
+    # Default: general reasoning
+    return [
+        "Understand the question and identify the core task",
+        "Break the problem into smaller sub-problems",
+        "Address each sub-problem in order",
+        "Synthesise a complete and accurate answer",
+    ]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Confidence estimator
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _estimate_confidence(
+    user_input: str,
+    problem_type: str,
+    intent: str,
+    has_symbolic_result: bool = False,
+) -> str:
+    """Heuristically estimate confidence in the system's ability to answer."""
+    if has_symbolic_result:
+        return "HIGH"  # SymPy computed it — we're certain
+
+    lowered = user_input.lower()
+
+    # High confidence for well-defined math types
+    high_confidence_types = {
+        "integration", "differentiation", "limit_evaluation",
+        "equation_solving", "factorization", "algebraic_expansion",
+        "simplification", "series_expansion", "number_theory",
+        "statistical_analysis", "combinatorics",
+    }
+    if problem_type in high_confidence_types:
+        return "HIGH"
+
+    # Medium confidence for conceptual / knowledge
+    if intent in ("knowledge", "conversation"):
+        # Simple factual questions tend to be higher confidence
+        if any(kw in lowered for kw in ["what is", "define", "who is"]):
+            return "MEDIUM"
+        # Open-ended or opinion questions are lower
+        if any(kw in lowered for kw in ["why", "opinion", "best", "should i"]):
+            return "LOW"
+        return "MEDIUM"
+
+    return "MEDIUM"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Warnings detector
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _detect_warnings(user_input: str, problem_type: str) -> list[str]:
+    """Flag potential issues in the problem statement."""
+    warnings = []
+    lowered = user_input.lower()
+
+    if len(user_input.strip()) < 5:
+        warnings.append("Input is very short — may be ambiguous")
+
+    if problem_type == "equation_solving" and "=" not in user_input and "solve" in lowered:
+        warnings.append("No '=' found — treating expression as equal to 0")
+
+    if problem_type == "integration" and "from" in lowered and "to" not in lowered:
+        warnings.append("'from' found but 'to' is missing — treating as indefinite integral")
+
+    if problem_type in ("differentiation", "integration") and not any(
+        c in user_input for c in list("xyztnkabcmnpqrs")
+    ):
+        warnings.append("No variable detected — defaulting to x")
+
+    if "undefined" in lowered or "infinity" in lowered:
+        warnings.append("Expression may involve singularities or unbounded behaviour")
+
+    return warnings
+
+
+# ────────────────────────────────────────────────────────────────���────────────
+# Public interface
+# ─────────────────────────────────────────────────────────────────────────────
+
+class ReasoningEngine:
+    """
+    Chain-of-Thought reasoning engine.
+
+    Usage:
+        re = ReasoningEngine()
+        plan = re.analyze(user_input, intent)
+        prompt = re.build_math_prompt(user_input, sympy_result, plan)
+        prompt = re.build_general_prompt(user_input, intent, context, plan)
+    """
+
+    def analyze(
+        self,
+        user_input: str,
+        intent: str,
+        has_symbolic_result: bool = False,
+    ) -> ReasoningPlan:
+        """
+        Produce a structured ReasoningPlan for the given input.
+
+        Args:
+            user_input: Raw user query.
+            intent: Classified intent (advanced_math / math / knowledge / conversation).
+            has_symbolic_result: True when SymPy has already computed the answer.
+
+        Returns:
+            ReasoningPlan with problem type, strategy, sub-problems, confidence.
+        """
+        lowered = user_input.lower()
+
+        # 1. Detect domain
+        domain = "general"
+        for d, keywords in _DOMAIN_HINTS.items():
+            for kw in keywords:
+                if kw in lowered:
+                    domain = d
+                    break
+            if domain != "general":
+                break
+
+        # 2. Classify problem type (list preserves priority order)
+        problem_type = "unknown"
+        for pattern, ptype in _PROBLEM_TYPE_PATTERNS:
+            if re.search(pattern, lowered):
+                problem_type = ptype
+                break
+
+        # 3. Strategy & expected answer form
+        strategy     = _STRATEGIES.get(problem_type, _STRATEGIES["unknown"])
+        expected_form = _EXPECTED_FORMS.get(problem_type, "")
+
+        # 4. Decompose into sub-problems
+        sub_problems = _decompose(user_input, problem_type, intent)
+
+        # 5. Detect assumptions
+        assumptions = []
+        if domain in ("calculus", "algebra", "differential_equations"):
+            if not any(kw in lowered for kw in ["complex", "imaginary", "i^2"]):
+                assumptions.append("Working over the real numbers unless otherwise stated")
+        if problem_type in ("integration", "differentiation"):
+            assumptions.append("Function is sufficiently smooth (differentiable/integrable)")
+
+        # 6. Warnings
+        warnings = _detect_warnings(user_input, problem_type)
+
+        # 7. Confidence
+        confidence = _estimate_confidence(
+            user_input, problem_type, intent, has_symbolic_result
+        )
+
+        return ReasoningPlan(
+            problem_type=problem_type,
+            domain=domain,
+            sub_problems=sub_problems,
+            strategy=strategy,
+            expected_form=expected_form,
+            assumptions=assumptions,
+            confidence=confidence,
+            reasoning_steps=sub_problems,
+            warnings=warnings,
+        )
+
+    def build_math_prompt(
+        self,
+        user_input: str,
+        sympy_result: str,
+        plan: ReasoningPlan,
+    ) -> str:
+        """
+        Build an LLM prompt for advanced math where SymPy has the correct answer.
+        The prompt embeds the full reasoning plan so the LLM follows the exact strategy.
+        """
+        steps_str = "\n".join(
+            f"  Step {i}: {s}" for i, s in enumerate(plan.sub_problems, 1)
+        )
+        assumptions_str = (
+            ("\nAssumptions: " + "; ".join(plan.assumptions))
+            if plan.assumptions else ""
+        )
+        expected_str = (
+            f"\nExpected answer form: {plan.expected_form}"
+            if plan.expected_form else ""
+        )
+
+        return (
+            f"PROBLEM: {user_input}\n\n"
+            f"VERIFIED ANSWER (computed by SymPy — 100% correct): {sympy_result}\n\n"
+            "=== YOUR TASK ===\n"
+            f"Explain, step by step, HOW a student arrives at: {sympy_result}\n"
+            "Do NOT recompute the answer. Do NOT give a different answer. "
+            "Your explanation must lead to exactly the verified answer above.\n\n"
+            f"TECHNIQUE: {plan.strategy}\n"
+            f"DOMAIN: {plan.domain}"
+            f"{expected_str}"
+            f"{assumptions_str}\n\n"
+            f"STEPS TO WALK THROUGH:\n{steps_str}\n\n"
+            "Write a numbered explanation. For each step:\n"
+            "  - State what you are doing and why.\n"
+            "  - Show the algebra or calculation clearly.\n"
+            "  - Connect it to the next step.\n\n"
+            f"End with: 'Final answer: {sympy_result}' — use this exact wording."
+        )
+
+    def build_general_prompt(
+        self,
+        user_input: str,
+        intent: str,
+        context: str,
+        plan: ReasoningPlan,
+    ) -> str:
+        """
+        Build an LLM prompt for knowledge/conversation using chain-of-thought.
+        The plan is embedded so the LLM follows the structured reasoning trace.
+        """
+        steps_str = "\n".join(
+            f"  {i}. {s}" for i, s in enumerate(plan.sub_problems, 1)
+        )
+        context_block = (
+            f"\nRELEVANT CONTEXT:\n{context}\n" if context else ""
+        )
+        confidence_note = (
+            "\nNote: confidence in this answer is LOW — state clearly if uncertain."
+            if plan.confidence == "LOW" else ""
+        )
+        warnings_block = ""
+        if plan.warnings:
+            warnings_block = "\nFLAGS: " + "; ".join(plan.warnings) + "\n"
+
+        return (
+            "You are AnveshAI, a helpful and honest AI assistant.\n"
+            f"QUESTION: {user_input}\n"
+            f"{context_block}"
+            f"{warnings_block}\n"
+            f"REASONING PLAN (follow this structure):\n{steps_str}\n\n"
+            f"ANSWER STRATEGY: {plan.strategy}\n"
+            f"{confidence_note}\n\n"
+            "Write a clear, thorough, well-structured response that follows "
+            "the reasoning plan above step by step. "
+            "Be concise but complete. State any assumptions or caveats explicitly."
+        )
+
+    def build_math_fallback_prompt(
+        self,
+        user_input: str,
+        plan: ReasoningPlan,
+        error_context: str = "",
+    ) -> str:
+        """
+        Prompt for when SymPy fails and the LLM must solve from scratch.
+        Uses chain-of-thought to maximise correctness.
+        """
+        steps_str = "\n".join(
+            f"  Step {i}: {s}" for i, s in enumerate(plan.sub_problems, 1)
+        )
+        error_note = (
+            f"\nNote: automated computation failed ({error_context}). "
+            "Solve manually with extra care.\n" if error_context else ""
+        )
+
+        return (
+            "You are a mathematics expert.\n"
+            f"PROBLEM: {user_input}\n"
+            f"{error_note}\n"
+            f"PROBLEM TYPE: {plan.problem_type}\n"
+            f"STRATEGY: {plan.strategy}\n"
+            f"{f'EXPECTED ANSWER FORM: {plan.expected_form}' if plan.expected_form else ''}\n\n"
+            f"REASONING STEPS TO FOLLOW:\n{steps_str}\n\n"
+            "Solve the problem completely by following each step above. "
+            "Show all working in full — do not skip steps. "
+            "State the final answer clearly at the end."
+        )

requirements.txt

@@ -0,0 +1,4 @@
+colorama>=0.4.6
+sympy>=1.12
+llama-cpp-python>=0.3.0
+huggingface-hub>=0.23.0

router.py

@@ -0,0 +1,134 @@
+"""
+Intent Router — classifies user input into one of five categories:
+    - system        : /commands
+    - advanced_math : calculus, algebra, limits, matrices, series, etc.
+    - math          : plain arithmetic (numbers only)
+    - knowledge     : factual questions answered from the knowledge base
+    - conversation  : everything else (chat, small talk, open questions)
+"""
+
+import re
+
+
+# ── Advanced math detection ───────────────────────────────────────────────────
+# These keywords signal symbolic / advanced mathematics.
+# Checked BEFORE the simple-arithmetic detector.
+ADVANCED_MATH_KEYWORDS = [
+    # Calculus
+    "integrate", "integral", "antiderivative", "indefinite integral",
+    "definite integral", "∫",
+    "differentiate", "derivative", "d/dx", "d/dy", "d/dz", "d/dt",
+    "second derivative", "third derivative", "nth derivative", "partial derivative",
+    "limit of", "limit as", "lim ", "find the limit",
+    # Differential equations
+    "differential equation", "ode ", "dsolve", "solve the ode",
+    "y'' ", "y' ", "d2y", "d^2y",
+    # Algebra / equations
+    "solve ", "find roots", "zeros of", "find the value of x",
+    # Linear algebra
+    "eigenvalue", "eigenvector", "determinant of", "det of",
+    "inverse matrix", "matrix inverse", "rank of matrix", "matrix rank",
+    "trace of matrix", "matrix trace", "characteristic polynomial",
+    # Series & transforms
+    "taylor series", "maclaurin series", "series expansion", "power series",
+    "laplace transform", "laplace of", "inverse laplace",
+    "fourier transform", "fourier of",
+    # Symbolic manipulation
+    "simplify ", "simplify(", "factor ", "factorise", "factorize",
+    "expand ", "partial fraction",
+    # Number theory
+    "gcd(", "gcd of", "greatest common divisor", "highest common factor",
+    "lcm(", "lcm of", "least common multiple",
+    "prime factor", "prime factorization",
+    " mod ", "modulo ", "modular inverse",
+    # Statistics
+    "mean of", "average of", "median of", "variance of",
+    "standard deviation of", "std dev of",
+    # Combinatorics
+    "factorial of", "factorial(", "binomial coefficient",
+    "choose ", "nCr", "nPr", "permutation",
+    # Summations & products
+    "sum of ", "summation of", "∑", "∏",
+    # Complex numbers
+    "complex number", "real part of", "imaginary part of",
+    "modulus of", "argument of", "conjugate of",
+    # Trigonometric identity simplification
+    "simplify trig", "trig simplif", "trigonometric simplif",
+]
+
+# ── Simple arithmetic detection ───────────────────────────────────────────────
+MATH_PATTERN = re.compile(
+    r"""
+    ^           # start of string
+    \s*         # optional leading whitespace
+    [\d\s\(\)]  # starts with digit, space, or parenthesis
+    [\d\s\+\-\*\/\%\^\(\)\.]*  # followed by math characters
+    $           # end of string
+    """,
+    re.VERBOSE,
+)
+
+ARITHMETIC_PREFIXES = ("calculate", "compute", "evaluate", "what is")
+
+# ── Knowledge detection ───────────────────────────────────────────────────────
+KNOWLEDGE_KEYWORDS = [
+    "what is", "what are", "who is", "who are", "explain", "define",
+    "tell me about", "describe", "how does", "why is", "when was",
+    "where is", "history of", "meaning of", "difference between",
+    "knowledge", "information about", "learn about", "facts about",
+]
+
+# ── System commands ───────────────────────────────────────────────────────────
+SYSTEM_PATTERN = re.compile(r"^/\w+")
+
+
+def classify_intent(user_input: str) -> str:
+    """
+    Classify user input and return one of:
+        'system' | 'advanced_math' | 'math' | 'knowledge' | 'conversation'
+    """
+    text   = user_input.strip()
+    lowered = text.lower()
+
+    # 1. System commands (/exit, /help, /history)
+    if SYSTEM_PATTERN.match(text):
+        return "system"
+
+    # 2. Advanced math — symbolic operations (checked before simple math)
+    for kw in ADVANCED_MATH_KEYWORDS:
+        if kw in lowered:
+            return "advanced_math"
+
+    # 3. Simple arithmetic — numbers and operators only
+    if _is_simple_arithmetic(text, lowered):
+        return "math"
+
+    # 4. Knowledge questions
+    for kw in KNOWLEDGE_KEYWORDS:
+        if kw in lowered:
+            return "knowledge"
+
+    # 5. Fallback — conversation / LLM
+    return "conversation"
+
+
+def _is_simple_arithmetic(text: str, lowered: str) -> bool:
+    """True if the input is a plain numeric arithmetic expression."""
+    # Allow optional natural-language prefix before checking expression
+    remainder = lowered
+    for prefix in ARITHMETIC_PREFIXES:
+        if lowered.startswith(prefix):
+            remainder = lowered[len(prefix):].strip()
+            break
+
+    # Must have at least one digit and one operator
+    has_digit    = any(ch.isdigit() for ch in remainder)
+    has_operator = any(ch in "+-*/%^" for ch in remainder)
+    # Must NOT contain letters beyond simple operators (no variables)
+    has_letters  = bool(re.search(r'[a-zA-Z]', remainder))
+
+    if has_digit and has_operator and not has_letters:
+        return True
+
+    # Also match pure numeric patterns via regex
+    return bool(MATH_PATTERN.match(text))