demathpy 0.0.1__tar.gz

demathpy-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Misekai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

demathpy-0.0.1/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: demathpy
+Version: 0.0.1
+Summary: PDE/ODE math backend
+Author: Misekai
+Author-email: Misekai <mcore-us@misekai.net>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: sympy>=1.12.0
+Requires-Dist: typing>=3.10.0.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Demathpy
+
+A Python library for parsing and safely evaluating symbolic Ordinary and Partial Differential Equations (ODEs/PDEs) on numerical grids.
+
+This repository provides:
+
+- A lightweight **symbol normalizer** that converts human-readable mathematical notation into valid Python expressions.
+- A **secure evaluation engine** that evaluates PDE/ODE right-hand sides on NumPy grids without using raw `eval` on untrusted input.
+- Built-in support for common differential operators and vector calculus notation.
+
+### Key Features
+
+#### 1. Symbol Normalization
+
+The parser supports Unicode and mathematical shorthand, including:
+
+- Greek letters: `α, β, γ, λ, ε, φ, θ` → `alpha, beta, gamma, lam, epsilon, phi, theta`
+- Powers: `u², v³` → `u**2, v**3`
+- Implicit multiplication:  
+  - `αu` → `alpha*u`  
+  - `2u` → `2*u`  
+  - `(u+1)(v+1)` → `(u+1)*(v+1)`
+- Absolute values: `|u|` → `abs(u)`
+- Common functions:  
+  `sin, cos, tan, exp, log, tanh, sech, sign, sqrt`
+
+#### 2. Differential Operator Support
+
+The parser recognizes and evaluates:
+
+- First derivatives:
+  - `du/dt`, `u_t`
+- Second derivatives:
+  - `dxx(u)`, `dzz(u)`
+- Laplacian:
+  - `∇²u`, `lap(u)`
+- Gradient:
+  - `∇u`, `grad(u)`
+- Divergence:
+  - `∇·(A)`, `div(A)`
+
+These are mapped to finite-difference operators implemented in NumPy.
+
+#### 3. PDE / ODE Parsing
+
+The library provides:
+
+- `parse_pde(equation: str)`  
+  Parses a PDE string and returns `(lhs_variable, rhs_expression)`.
+
+- `evaluate_rhs(rhs: str, grids: dict, constants: dict, grid_dx: float)`  
+  Safely evaluates the right-hand side on NumPy arrays representing fields and parameters.
+
+Supports equations such as:
+
+```text
+∂T/∂t = α ∇²T - σ T
+u_t = D dxx(u) + f(u)
+∂φ/∂t = ∇·((1 + T²) ∇φ)
+```
+#### 4. Secure Evaluation Environment
+Only a restricted set of functions and operators are exposed.
+No access to Python builtins, file I/O, or unsafe functions.
+All variables must come from:
+grids: NumPy arrays for fields (u, T, phi, etc.)
+constants: scalar parameters (alpha, beta, lambda, etc.)
+#### 5. Coordinate-Aware PDEs
+The evaluator automatically provides spatial coordinate grids:
+x, z as NumPy arrays derived from grid shape and spacing.
+This enables anisotropic and spatially varying coefficients such as:
+``` α x dxx(T) + α z dzz(T)```
+Typical Use:
+
+```text 
+from pde import parse_pde, evaluate_rhs
+
+lhs, rhs = parse_pde("∂T/∂t = α ∇²T - σ T")
+
+result = evaluate_rhs(
+    rhs,
+    grids={"T": T_grid},
+    constants={"alpha": 0.1, "sigma": 0.01},
+    grid_dx=0.01
+)
+```
+
+#### 6. Purpose
+This project is intended as a safe mathematical expression parser for:
+Scientific computing
+PDE/ODE solvers
+Physics and engineering simulations
+Educational or sandboxed equation evaluation

demathpy-0.0.1/README.md

@@ -0,0 +1,92 @@
+# Demathpy
+
+A Python library for parsing and safely evaluating symbolic Ordinary and Partial Differential Equations (ODEs/PDEs) on numerical grids.
+
+This repository provides:
+
+- A lightweight **symbol normalizer** that converts human-readable mathematical notation into valid Python expressions.
+- A **secure evaluation engine** that evaluates PDE/ODE right-hand sides on NumPy grids without using raw `eval` on untrusted input.
+- Built-in support for common differential operators and vector calculus notation.
+
+### Key Features
+
+#### 1. Symbol Normalization
+
+The parser supports Unicode and mathematical shorthand, including:
+
+- Greek letters: `α, β, γ, λ, ε, φ, θ` → `alpha, beta, gamma, lam, epsilon, phi, theta`
+- Powers: `u², v³` → `u**2, v**3`
+- Implicit multiplication:  
+  - `αu` → `alpha*u`  
+  - `2u` → `2*u`  
+  - `(u+1)(v+1)` → `(u+1)*(v+1)`
+- Absolute values: `|u|` → `abs(u)`
+- Common functions:  
+  `sin, cos, tan, exp, log, tanh, sech, sign, sqrt`
+
+#### 2. Differential Operator Support
+
+The parser recognizes and evaluates:
+
+- First derivatives:
+  - `du/dt`, `u_t`
+- Second derivatives:
+  - `dxx(u)`, `dzz(u)`
+- Laplacian:
+  - `∇²u`, `lap(u)`
+- Gradient:
+  - `∇u`, `grad(u)`
+- Divergence:
+  - `∇·(A)`, `div(A)`
+
+These are mapped to finite-difference operators implemented in NumPy.
+
+#### 3. PDE / ODE Parsing
+
+The library provides:
+
+- `parse_pde(equation: str)`  
+  Parses a PDE string and returns `(lhs_variable, rhs_expression)`.
+
+- `evaluate_rhs(rhs: str, grids: dict, constants: dict, grid_dx: float)`  
+  Safely evaluates the right-hand side on NumPy arrays representing fields and parameters.
+
+Supports equations such as:
+
+```text
+∂T/∂t = α ∇²T - σ T
+u_t = D dxx(u) + f(u)
+∂φ/∂t = ∇·((1 + T²) ∇φ)
+```
+#### 4. Secure Evaluation Environment
+Only a restricted set of functions and operators are exposed.
+No access to Python builtins, file I/O, or unsafe functions.
+All variables must come from:
+grids: NumPy arrays for fields (u, T, phi, etc.)
+constants: scalar parameters (alpha, beta, lambda, etc.)
+#### 5. Coordinate-Aware PDEs
+The evaluator automatically provides spatial coordinate grids:
+x, z as NumPy arrays derived from grid shape and spacing.
+This enables anisotropic and spatially varying coefficients such as:
+``` α x dxx(T) + α z dzz(T)```
+Typical Use:
+
+```text 
+from pde import parse_pde, evaluate_rhs
+
+lhs, rhs = parse_pde("∂T/∂t = α ∇²T - σ T")
+
+result = evaluate_rhs(
+    rhs,
+    grids={"T": T_grid},
+    constants={"alpha": 0.1, "sigma": 0.01},
+    grid_dx=0.01
+)
+```
+
+#### 6. Purpose
+This project is intended as a safe mathematical expression parser for:
+Scientific computing
+PDE/ODE solvers
+Physics and engineering simulations
+Educational or sandboxed equation evaluation

demathpy-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+
+[project]
+name = "demathpy"
+version = "0.0.1"
+authors = [
+  { name="Misekai", email="mcore-us@misekai.net" },
+]
+description = "PDE/ODE math backend"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=1.24.0",
+    "sympy>=1.12.0",
+    "typing>=3.10.0.0",
+]
+
+
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[build-system]
+requires = ["uv_build >= 0.9.26, <0.10.0"]
+build-backend = "uv_build"
+

demathpy-0.0.1/src/demathpy/__init__.py

@@ -0,0 +1,33 @@
+"""demathpy: PDE/ODE math backend for rde-core."""
+
+from .symbols import normalize_symbols, normalize_lhs
+from .pde import (
+    normalize_pde,
+    init_grid,
+    sample_gradient,
+    parse_pde,
+    evaluate_rhs,
+    evaluate_scalar,
+    step_pdes,
+    evaluate_rhs_compiled,
+    evaluate_scalar_compiled,
+    step_compiled_pdes,
+)
+from .ode import robust_parse, parse_odes_to_function
+
+__all__ = [
+    "normalize_symbols",
+    "normalize_lhs",
+    "normalize_pde",
+    "init_grid",
+    "sample_gradient",
+    "parse_pde",
+    "evaluate_rhs",
+    "evaluate_scalar",
+    "step_pdes",
+    "evaluate_rhs_compiled",
+    "evaluate_scalar_compiled",
+    "step_compiled_pdes",
+    "robust_parse",
+    "parse_odes_to_function",
+]

demathpy-0.0.1/src/demathpy/ode.py

@@ -0,0 +1,131 @@
+import json
+import re
+import sympy
+import numpy as np
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application, convert_xor
+
+
+def _convert_ternary(expr: str) -> str:
+    """
+    Convert a single C-style ternary (cond ? a : b) into SymPy Piecewise.
+    Supports one level (no nesting).
+    """
+    if "?" not in expr or ":" not in expr:
+        return expr
+
+    # naive split for single ternary
+    # pattern: <cond> ? <a> : <b>
+    parts = expr.split("?")
+    if len(parts) != 2:
+        return expr
+    cond = parts[0].strip()
+    rest = parts[1]
+    if ":" not in rest:
+        return expr
+    a, b = rest.split(":", 1)
+    a = a.strip()
+    b = b.strip()
+    return f"Piecewise(({a}, {cond}), ({b}, True))"
+
+
+def robust_parse(expr_str):
+    """
+    Parses a string into a SymPy expression with relaxed syntax rules:
+    - Implicit multiplication (5x -> 5*x)
+    - Caret for power (x^2 -> x**2)
+    - Aliases 'y' to 'z' for 2D convenience
+    """
+    if not isinstance(expr_str, str):
+        return sympy.sympify(expr_str) 
+        
+    transformations = (standard_transformations + (implicit_multiplication_application, convert_xor))
+    
+    # Define symbols and alias y -> z
+    x, z, vx, vz, t, pid = sympy.symbols('x z vx vz t id')
+    local_dict = {
+        'x': x, 'z': z, 'y': z, 'vx': vx, 'vz': vz, 't': t, 'id': pid,
+        'pi': sympy.pi, 'e': sympy.E
+    }
+
+    # Ensure common functions are recognized (Abs not abs)
+    local_dict.update({
+        'sin': sympy.sin,
+        'cos': sympy.cos,
+        'tan': sympy.tan,
+        'exp': sympy.exp,
+        'sqrt': sympy.sqrt,
+        'log': sympy.log,
+        'abs': sympy.Abs,
+        'Abs': sympy.Abs,
+        'Piecewise': sympy.Piecewise,
+    })
+
+    try:
+        pre = _convert_ternary(expr_str)
+        return parse_expr(pre, transformations=transformations, local_dict=local_dict)
+    except Exception:
+        # Fallback
+        return sympy.sympify(expr_str, locals=local_dict)
+
+
+def parse_odes_to_function(ode_json_str):
+    """
+    Parses a JSON string of ODEs and returns a dynamic update function.
+    """
+    try:
+        if isinstance(ode_json_str, str):
+            odes = json.loads(ode_json_str)
+        else:
+            odes = ode_json_str
+    except json.JSONDecodeError as e:
+        print(f"Failed to decode JSON from LLM: {e}")
+        return None
+
+    # Define standard symbols
+    x, z, vx, vz, t = sympy.symbols('x z vx vz t')
+    
+    deriv_map = {}
+    keys = ['dx', 'dz', 'dvx', 'dvz']
+    
+    for key in keys:
+        expr_str = odes.get(key, "0")
+        try:
+            # Parse the expression safely using robust parser
+            expr = robust_parse(str(expr_str))
+            
+            # Create a localized function
+            # Arguments match the order we will call them
+            func = sympy.lambdify((x, z, vx, vz, t), expr, modules=['numpy', 'math'])
+            deriv_map[key] = func
+        except Exception as e:
+            print(f"Error parsing expression for {key}: {e}")
+            return None
+
+    def dynamics(particle, dt):
+        # Current state
+        cx, cz, cvx, cvz = particle.x, particle.z, particle.vx, particle.vz
+        # We assume particle might track time, or we just pass 0 if autonomous
+        ct = getattr(particle, 'time', 0.0)
+        
+        try:
+            # Calculate derivatives
+            val_dx = deriv_map['dx'](cx, cz, cvx, cvz, ct)
+            val_dz = deriv_map['dz'](cx, cz, cvx, cvz, ct)
+            val_dvx = deriv_map['dvx'](cx, cz, cvx, cvz, ct)
+            val_dvz = deriv_map['dvz'](cx, cz, cvx, cvz, ct)
+            
+            # Simple Euler Integration
+            particle.x += float(val_dx) * dt
+            particle.z += float(val_dz) * dt
+            particle.vx += float(val_dvx) * dt
+            particle.vz += float(val_dvz) * dt
+            
+            # Update time if tracked
+            if hasattr(particle, 'time'):
+                particle.time += dt
+                
+        except Exception as e:
+            # Prevent crashing the renderer on math errors (e.g. div by zero)
+            print(f"Runtime error in dynamics: {e}")
+
+    return dynamics

demathpy-0.0.1/src/demathpy/pde.py

@@ -0,0 +1,422 @@
+"""
+Field math utilities (PDE/field-space helpers).
+
+Provides a grid-based PDE solver and sampling utilities for projecting
+field PDEs into particle motion without hardcoded dynamics.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Tuple
+
+import re
+import numpy as np
+
+from .symbols import normalize_symbols, normalize_lhs
+
+
+def normalize_pde(pde: str) -> str:
+    return (pde or "").strip()
+
+
+def init_grid(width: int, height: int, dx: float) -> Tuple[np.ndarray, float]:
+    nx = max(2, int(width / dx))
+    nz = max(2, int(height / dx))
+    grid = np.zeros((nz, nx), dtype=float)
+    return grid, dx
+
+
+def _preprocess_expr(expr: str) -> str:
+    expr = (expr or "").strip()
+    # Drop common annotation tokens (LLM outputs sometimes include these).
+    expr = re.sub(r"\(\s*approx\s*\)", "", expr, flags=re.IGNORECASE)
+    expr = re.sub(r"\bapprox\b", "", expr, flags=re.IGNORECASE)
+    # If the RHS contains multiple '=' (e.g. an annotated expansion), prefer the
+    # rightmost expression, which is typically the most explicit.
+    if "=" in expr:
+        expr = expr.split("=")[-1]
+    expr = normalize_symbols(expr)
+    return expr.strip()
+
+
+def parse_pde(pde: str) -> Tuple[str, int, str, str]:
+    """
+    Returns (var, order, lhs_coeff_expr, rhs_expr).
+    Supports forms:
+      ∂u/∂t = RHS
+      ∂²u/∂t² = RHS
+      ∂^n u / ∂t^n = RHS
+      rho(∂²u/∂t²) = RHS
+    """
+    pde = normalize_pde(pde)
+    if "=" not in pde:
+        return "u", 1, "1", pde
+
+    lhs, rhs = pde.split("=", 1)
+    lhs = normalize_lhs(lhs.strip())
+    rhs = rhs.strip()
+
+    def _extract_coeff(lhs_expr: str, deriv_expr: str) -> str:
+        coeff = lhs_expr.replace(deriv_expr, "").strip()
+        if not coeff:
+            return "1"
+        # Remove leading or trailing multiplication symbols
+        coeff = coeff.strip("*")
+        return _preprocess_expr(coeff) or "1"
+
+    # N-th order time derivative: ∂^n v / ∂t^n
+    # Matches patterns like: ∂^2 u / ∂t^2, ∂3u/∂t3, ∂ u / ∂t
+    # We normalized unicode `²` to `^2` in normalize_lhs.
+    
+    # Regex for derivative term
+    # breakdown:
+    #   ∂               literal partial
+    #   \s*             whitespace
+    #   (?:\^?(\d+))?   optional order: ^2, 2, or nothing (order 1)
+    #   \s*             whitespace
+    #   ([a-zA-Z_]\w*)  variable name (group 2)
+    #   \s*             whitespace
+    #   /               division
+    #   \s*             whitespace
+    #   ∂t              ∂t
+    #   (?:\^?(\d+))?   optional order at bottom: ^2, 2, or nothing
+    
+    pattern = r"∂\s*(?:\^?(\d+))?\s*([a-zA-Z_]\w*)\s*/\s*∂t\s*(?:\^?(\d+))?"
+    m = re.search(pattern, lhs)
+    
+    if m:
+        # group 1: order top, group 2: var, group 3: order bottom
+        # if inconsistent orders, we trust top or bottom if they match?
+        # Usually they match. If missing, assume 1.
+        ord1 = m.group(1)
+        var = m.group(2)
+        ord2 = m.group(3)
+        
+        order = 1
+        if ord1:
+            order = int(ord1)
+        elif ord2:
+            order = int(ord2)
+            
+        coeff = _extract_coeff(lhs, m.group(0))
+        return var, order, coeff, _preprocess_expr(rhs)
+
+    return "u", 1, "1", _preprocess_expr(rhs)
+
+
+def evolve_pde(grid: np.ndarray, dt: float, constants: dict) -> np.ndarray:
+    """
+    Generic PDE evolution step. Requires constants to define dynamics.
+    If no constants are provided, returns the grid unchanged.
+
+    Expected constants:
+    - alpha: diffusion coefficient (optional)
+    """
+    return grid
+
+
+def sample_gradient(grid: np.ndarray, x: float, z: float, dx: float) -> Tuple[float, float]:
+    if grid is None:
+        return 0.0, 0.0
+    nz, nx = grid.shape
+    ix = int(np.clip(x / dx, 1, nx - 2))
+    iz = int(np.clip(z / dx, 1, nz - 2))
+    du_dx = (grid[iz, ix + 1] - grid[iz, ix - 1]) / (2 * dx)
+    du_dz = (grid[iz + 1, ix] - grid[iz - 1, ix]) / (2 * dx)
+    return du_dx, du_dz
+
+
+def _build_eval_env(vars_grid: Dict[str, np.ndarray], constants: Dict[str, float], grid_dx: float) -> Dict[str, object]:
+    def lap(u):
+        return dxx(u) + dzz(u)
+
+    def dx(u):
+        return (np.roll(u, -1, axis=1) - np.roll(u, 1, axis=1)) / (2 * grid_dx)
+
+    def dz(u):
+        return (np.roll(u, -1, axis=0) - np.roll(u, 1, axis=0)) / (2 * grid_dx)
+
+    def dxx(u):
+        return (np.roll(u, -1, axis=1) - 2 * u + np.roll(u, 1, axis=1)) / (grid_dx ** 2)
+
+    def dzz(u):
+        return (np.roll(u, -1, axis=0) - 2 * u + np.roll(u, 1, axis=0)) / (grid_dx ** 2)
+
+    def gradmag(u):
+        return dx(u) ** 2 + dz(u) ** 2
+
+    def gradl1(u):
+        return np.abs(dx(u)) + np.abs(dz(u))
+
+    def grad(u):
+        # Return a 2x(HxW) array so scalar multiplication broadcasts naturally
+        # and div(...) can consume it.
+        return np.stack((dx(u), dz(u)), axis=0)
+
+    def div(v):
+        # Accept either a tuple/list (vx, vz) or a stacked array with shape (2, ...).
+        if isinstance(v, (tuple, list)) and len(v) == 2:
+            return dx(v[0]) + dz(v[1])
+        if isinstance(v, np.ndarray) and v.ndim >= 3 and v.shape[0] == 2:
+            return dx(v[0]) + dz(v[1])
+        return np.zeros_like(next(iter(vars_grid.values())))
+
+    def sech(u):
+        return 1.0 / np.cosh(u)
+
+    def sign(u):
+        return np.sign(u)
+
+    def pos(u):
+        return np.maximum(u, 0.0)
+
+    env = {
+        "np": np,
+        "sin": np.sin,
+        "cos": np.cos,
+        "tan": np.tan,
+        "sinh": np.sinh,
+        "cosh": np.cosh,
+        "tanh": np.tanh,
+        "arcsin": np.arcsin,
+        "arccos": np.arccos,
+        "arctan": np.arctan,
+        "log": np.log,
+        "log10": np.log10,
+        "log2": np.log2,
+        "exp": np.exp,
+        "sqrt": np.sqrt,
+        "abs": np.abs,
+        "pi": np.pi,
+        "inf": np.inf,
+        "lap": lap,
+        "dx": dx,
+        "dz": dz,
+        "dxx": dxx,
+        "dzz": dzz,
+        "gradmag": gradmag,
+        "gradl1": gradl1,
+        "grad": grad,
+        "div": div,
+        "pos": pos,
+        "sech": sech,
+        "sign": sign,
+    }
+
+    # Add constants
+    for k, v in (constants or {}).items():
+        env[k] = v
+
+    if "E" not in env:
+        env["E"] = np.e
+    if "e" not in env:
+        env["e"] = np.e
+
+    # Normalize common constant aliases used in test corpora / LLM outputs.
+    # - Users often provide 'lambda' and 'eps' in JSON to avoid Unicode / reserved keywords.
+    if "lambda" in env and "lam" not in env:
+        env["lam"] = env["lambda"]
+    if "eps" in env and "epsilon" not in env:
+        env["epsilon"] = env["eps"]
+
+    # Common aliasing for constants
+    if "w" in env and "omega" not in env:
+        env["omega"] = env["w"]
+    if "w2" in env and "omega2" not in env:
+        env["omega2"] = env["w2"]
+    if "ax" in env and "alphax" not in env:
+        env["alphax"] = env["ax"]
+    if "az" in env and "alphaz" not in env:
+        env["alphaz"] = env["az"]
+    if "th" in env and "theta" not in env:
+        env["theta"] = env["th"]
+    if "damp" in env and "zeta" not in env:
+        env["zeta"] = env["damp"]
+
+    # Provide time symbol if present
+    if "t" not in env:
+        env["t"] = float((constants or {}).get("t", 0.0))
+
+    # Add variable grids
+    for k, v in vars_grid.items():
+        env[k] = v
+
+    return env
+
+
+def evaluate_rhs(rhs_expr: str, vars_grid: Dict[str, np.ndarray], constants: Dict[str, float], grid_dx: float) -> np.ndarray:
+    """
+    Evaluate RHS expression on grid using numpy operations.
+    """
+    rhs_expr = _preprocess_expr(rhs_expr)
+    env = _build_eval_env(vars_grid, constants, grid_dx)
+
+    # Provide default zero grids for missing symbols referenced in RHS
+    if vars_grid:
+        zero_grid = np.zeros_like(next(iter(vars_grid.values())))
+        identifiers = set(re.findall(r"\b([A-Za-z_][A-Za-z0-9_]*)\b", rhs_expr))
+        reserved = {
+            "np",
+            "sin", "cos", "tan", "sinh", "cosh", "tanh",
+            "arcsin", "arccos", "arctan",
+            "exp", "sqrt", "abs", "log", "log10", "log2",
+            "sech", "sign",
+            "pi", "inf", "E", "e",
+            "lap", "dx", "dz", "dxx", "dzz", "grad", "div", "gradmag", "gradl1", "pos", "t",
+        }
+        for name in identifiers:
+            if name in reserved:
+                continue
+            if name not in env:
+                env[name] = zero_grid
+
+    if not vars_grid:
+        return np.zeros((2, 2), dtype=float)
+
+    try:
+        return eval(rhs_expr, {}, env)
+    except Exception as exc:
+        raise RuntimeError(f"PDE RHS eval failed for '{rhs_expr}': {exc}")
+
+
+def evaluate_rhs_compiled(rhs_expr: str, vars_grid: Dict[str, np.ndarray], constants: Dict[str, float], grid_dx: float) -> np.ndarray:
+    """Evaluate already-compiled RHS expression (no preprocessing)."""
+    env = _build_eval_env(vars_grid, constants, grid_dx)
+
+    if vars_grid:
+        zero_grid = np.zeros_like(next(iter(vars_grid.values())))
+        identifiers = set(re.findall(r"\b([A-Za-z_][A-Za-z0-9_]*)\b", rhs_expr))
+        reserved = {
+            "np",
+            "sin", "cos", "tan", "sinh", "cosh", "tanh",
+            "arcsin", "arccos", "arctan",
+            "exp", "sqrt", "abs", "log", "log10", "log2",
+            "sech", "sign",
+            "pi", "inf", "E", "e",
+            "lap", "dx", "dz", "dxx", "dzz", "grad", "div", "gradmag", "gradl1", "pos", "t",
+        }
+        for name in identifiers:
+            if name in reserved:
+                continue
+            if name not in env:
+                env[name] = zero_grid
+
+    if not vars_grid:
+        return np.zeros((2, 2), dtype=float)
+
+    try:
+        return eval(rhs_expr, {}, env)
+    except Exception as exc:
+        raise RuntimeError(f"PDE RHS eval failed for '{rhs_expr}': {exc}")
+
+
+def evaluate_scalar(expr: str, vars_grid: Dict[str, np.ndarray], constants: Dict[str, float], grid_dx: float) -> float:
+    """Evaluate a scalar coefficient expression with the same env as RHS."""
+    if expr in ("", "1"):
+        return 1.0
+    rhs = evaluate_rhs(expr, vars_grid, constants, grid_dx)
+    if np.isscalar(rhs):
+        return float(rhs)
+    try:
+        return float(np.mean(rhs))
+    except Exception as exc:
+        raise RuntimeError(f"PDE coeff eval failed for '{expr}': {exc}")
+
+
+def evaluate_scalar_compiled(expr: str, vars_grid: Dict[str, np.ndarray], constants: Dict[str, float], grid_dx: float) -> float:
+    """Evaluate scalar coefficient expression without preprocessing."""
+    if expr in ("", "1"):
+        return 1.0
+    rhs = evaluate_rhs_compiled(expr, vars_grid, constants, grid_dx)
+    if np.isscalar(rhs):
+        return float(rhs)
+    try:
+        return float(np.mean(rhs))
+    except Exception as exc:
+        raise RuntimeError(f"PDE coeff eval failed for '{expr}': {exc}")
+
+
+def step_pdes(
+    field_pdes: List[str],
+    grids: Dict[str, np.ndarray],
+    constants: Dict[str, float],
+    grid_dx: float,
+    dt: float,
+    external_grids: Dict[str, np.ndarray] | None = None,
+) -> List[str]:
+    """Advance PDEs by one time step. Returns list of error strings."""
+    errors: List[str] = []
+    if not field_pdes or not grids:
+        return errors
+
+    vars_grid = dict(grids)
+    if external_grids:
+        vars_grid.update(external_grids)
+
+    for pde in field_pdes:
+        try:
+            var, order, coeff_expr, rhs_expr = parse_pde(pde)
+            if var not in grids:
+                grids[var] = np.zeros_like(next(iter(grids.values())))
+
+            rhs = evaluate_rhs(rhs_expr, vars_grid, constants, grid_dx)
+            coeff = evaluate_scalar(coeff_expr, vars_grid, constants, grid_dx)
+            rhs = rhs / float(coeff or 1.0)
+
+            if order == 2:
+                vname = f"{var}_t"
+                if vname not in grids:
+                    grids[vname] = np.zeros_like(grids[var])
+                grids[vname] = grids[vname] + dt * rhs
+                grids[var] = grids[var] + dt * grids[vname]
+            else:
+                grids[var] = grids[var] + dt * rhs
+        except Exception as exc:
+            errors.append(f"PDE eval failed for '{pde}': {exc}")
+
+    return errors
+
+
+def step_compiled_pdes(
+    compiled_pdes: List[Dict[str, object]],
+    grids: Dict[str, np.ndarray],
+    constants: Dict[str, float],
+    grid_dx: float,
+    dt: float,
+    external_grids: Dict[str, np.ndarray] | None = None,
+) -> List[str]:
+    """Advance already-compiled PDEs. Returns list of error strings."""
+    errors: List[str] = []
+    if not compiled_pdes or not grids:
+        return errors
+
+    vars_grid = dict(grids)
+    if external_grids:
+        vars_grid.update(external_grids)
+
+    for entry in compiled_pdes:
+        try:
+            var = entry.get("var", "u")
+            order = int(entry.get("order", 1))
+            coeff_expr = str(entry.get("coeff_expr", "1"))
+            rhs_expr = str(entry.get("rhs_expr", "0"))
+
+            if var not in grids:
+                grids[var] = np.zeros_like(next(iter(grids.values())))
+
+            rhs = evaluate_rhs_compiled(rhs_expr, vars_grid, constants, grid_dx)
+            coeff = evaluate_scalar_compiled(coeff_expr, vars_grid, constants, grid_dx)
+            rhs = rhs / float(coeff or 1.0)
+
+            if order == 2:
+                vname = f"{var}_t"
+                if vname not in grids:
+                    grids[vname] = np.zeros_like(grids[var])
+                grids[vname] = grids[vname] + dt * rhs
+                grids[var] = grids[var] + dt * grids[vname]
+            else:
+                grids[var] = grids[var] + dt * rhs
+        except Exception as exc:
+            errors.append(f"PDE eval failed for '{entry}': {exc}")
+
+    return errors

demathpy-0.0.1/src/demathpy/symbols.py

@@ -0,0 +1,379 @@
+"""
+Symbol normalization utilities for PDE parsing.
+Converts Unicode math symbols and common LaTeX-like tokens to Python-callable forms.
+"""
+from __future__ import annotations
+
+import re
+from typing import Dict
+
+SYMBOL_MAP: Dict[str, str] = {
+    # Basic operators
+    "−": "-",
+    "×": "*",
+    "·": "*",
+    "÷": "/",
+    "^": "**",
+    "√": "sqrt",
+    "∞": "inf",
+    "π": "pi",
+    "Π": "pi",
+    "≈": "~",
+    "≠": "!=",
+    "≤": "<=",
+    "≥": ">=",
+    # Superscripts
+    "²": "**2",
+    "³": "**3",
+    "⁴": "**4",
+    "⁵": "**5",
+    "⁶": "**6",
+    "⁷": "**7",
+    "⁸": "**8",
+    "⁹": "**9",
+    "⁰": "**0",
+    "¹": "**1",
+    "⁺": "POSITIVE_PART",
+    # Subscripts
+    "₀": "0",
+    "₁": "1",
+    "₂": "2",
+    "₃": "3",
+    "₄": "4",
+    "₅": "5",
+    "₆": "6",
+    "₇": "7",
+    "₈": "8",
+    "₉": "9",
+    # Greek letters
+    "α": "alpha",
+    "β": "beta",
+    "γ": "gamma",
+    "δ": "delta",
+    "ε": "epsilon",
+    "ζ": "zeta",
+    "η": "eta",
+    "θ": "theta",
+    "ι": "iota",
+    "κ": "kappa",
+    "λ": "lam",
+    "μ": "mu",
+    "ν": "nu",
+    "ξ": "xi",
+    "ο": "omicron",
+    "π": "pi",
+    "ρ": "rho",
+    "σ": "sigma",
+    "τ": "tau",
+    "υ": "upsilon",
+    "φ": "phi",
+    "χ": "chi",
+    "ψ": "psi",
+    "ω": "omega",
+    "Α": "alpha",
+    "Β": "beta",
+    "Γ": "gamma",
+    "Δ": "delta",
+    "Ε": "epsilon",
+    "Ζ": "zeta",
+    "Η": "eta",
+    "Θ": "theta",
+    "Ι": "iota",
+    "Κ": "kappa",
+    "Λ": "lam",
+    "Μ": "mu",
+    "Ν": "nu",
+    "Ξ": "xi",
+    "Ο": "omicron",
+    "Π": "pi",
+    "Ρ": "rho",
+    "Σ": "sigma",
+    "Τ": "tau",
+    "Υ": "upsilon",
+    "Φ": "phi",
+    "Χ": "chi",
+    "Ψ": "psi",
+    "Ω": "omega",
+    # Common math functions (unicode to ascii word if present)
+    "∂": "",
+    "Δ": "lap",
+}
+
+LHS_SYMBOL_MAP: Dict[str, str] = {
+    # Keep ∂ intact for LHS parsing but normalize greek
+    "α": "alpha",
+    "β": "beta",
+    "γ": "gamma",
+    "δ": "delta",
+    "ε": "epsilon",
+    "ζ": "zeta",
+    "η": "eta",
+    "θ": "theta",
+    "ι": "iota",
+    "κ": "kappa",
+    "λ": "lam",
+    "μ": "mu",
+    "ν": "nu",
+    "ξ": "xi",
+    "ο": "omicron",
+    "π": "pi",
+    "ρ": "rho",
+    "σ": "sigma",
+    "τ": "tau",
+    "υ": "upsilon",
+    "φ": "phi",
+    "χ": "chi",
+    "ψ": "psi",
+    "ω": "omega",
+    "Α": "alpha",
+    "Β": "beta",
+    "Γ": "gamma",
+    "Δ": "delta",
+    "Ε": "epsilon",
+    "Ζ": "zeta",
+    "Η": "eta",
+    "Θ": "theta",
+    "Ι": "iota",
+    "Κ": "kappa",
+    "Λ": "lam",
+    "Μ": "mu",
+    "Ν": "nu",
+    "Ξ": "xi",
+    "Ο": "omicron",
+    "Π": "pi",
+    "Ρ": "rho",
+    "Σ": "sigma",
+    "Τ": "tau",
+    "Υ": "upsilon",
+    "Φ": "phi",
+    "Χ": "chi",
+    "Ψ": "psi",
+    "Ω": "omega",
+    # Superscripts for LHS
+    "²": "^2",
+    "³": "^3",
+    "⁴": "^4",
+    "⁵": "^5",
+    "⁶": "^6",
+    "⁷": "^7",
+    "⁸": "^8",
+    "⁹": "^9",
+}
+
+# Regex replacements for structured operators
+REGEX_RULES = [
+    # divergence operator: ∇·u or ∇·(u)
+    (r"∇\s*·\s*\(([^\)]*)\)", r"div(\1)"),
+    (r"∇\s*·\s*([a-zA-Z_][a-zA-Z0-9_]*)", r"div(\1)"),
+    # divergence shorthand: ∇ * u or ∇ * (u)
+    (r"∇\s*\*\s*\(([^\)]*)\)", r"div(\1)"),
+    (r"∇\s*\*\s*([a-zA-Z_][a-zA-Z0-9_]*)", r"div(\1)"),
+    # gradient: ∇(u)
+    (r"∇\s*\(([^\)]*)\)", r"grad(\1)"),
+    # gradient magnitude |∇u|^2
+    (r"\|\s*∇\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\|\^?2", r"gradmag(\1)"),
+    # Laplacian
+    (r"∇²\s*([a-zA-Z_][a-zA-Z0-9_]*)", r"lap(\1)"),
+    # Gradient
+    (r"∇\s*([a-zA-Z_][a-zA-Z0-9_]*)", r"grad(\1)"),
+]
+
+
+def normalize_symbols(expr: str) -> str:
+    if not expr:
+        return ""
+
+    # --- Helpers ---------------------------------------------------------
+    def _replace_balanced_paren_call(s: str, start_idx: int, fn_name: str, op_len: int) -> tuple[str, int] | None:
+        """Replace an operator call like '∇·( ... )' (possibly nested) with 'div( ... )'.
+
+        Args:
+            s: input string
+            start_idx: index where the operator starts (the '∇')
+            fn_name: replacement function name (e.g. 'div' or 'grad')
+            op_len: number of characters to skip from start_idx to the '(' (inclusive of operator symbols)
+
+        Returns:
+            (new_string, next_scan_index) or None if no balanced paren call found.
+        """
+        # Find the '(' that starts the argument list
+        i = start_idx + op_len
+        while i < len(s) and s[i].isspace():
+            i += 1
+        if i >= len(s) or s[i] != "(":
+            return None
+
+        # Find matching ')'
+        depth = 0
+        j = i
+        while j < len(s):
+            ch = s[j]
+            if ch == "(":
+                depth += 1
+            elif ch == ")":
+                depth -= 1
+                if depth == 0:
+                    inner = s[i + 1 : j]
+                    replaced = f"{fn_name}({inner})"
+                    new_s = s[:start_idx] + replaced + s[j + 1 :]
+                    return new_s, start_idx + len(replaced)
+            j += 1
+        return None
+
+    # Normalize greek letters early so time-derivative regex can match
+    greek_map = {
+        "α": "alpha", "β": "beta", "γ": "gamma", "δ": "delta", "ε": "epsilon",
+        "ζ": "zeta", "η": "eta", "θ": "theta", "ι": "iota", "κ": "kappa",
+        "λ": "lam", "μ": "mu", "ν": "nu", "ξ": "xi", "ο": "omicron",
+        "π": "pi", "ρ": "rho", "σ": "sigma", "τ": "tau", "υ": "upsilon",
+        "φ": "phi", "χ": "chi", "ψ": "psi", "ω": "omega",
+        "Α": "alpha", "Β": "beta", "Γ": "gamma", "Δ": "delta", "Ε": "epsilon",
+        "Ζ": "zeta", "Η": "eta", "Θ": "theta", "Ι": "iota", "Κ": "kappa",
+        "Λ": "lam", "Μ": "mu", "Ν": "nu", "Ξ": "xi", "Ο": "omicron",
+        "Π": "pi", "Ρ": "rho", "Σ": "sigma", "Τ": "tau", "Υ": "upsilon",
+        "Φ": "phi", "Χ": "chi", "Ψ": "psi", "Ω": "omega",
+    }
+    for k, v in greek_map.items():
+        expr = expr.replace(k, v)
+
+    # Strip stray question marks sometimes added by LLM output
+    expr = expr.replace("?", "")
+
+    # Normalize common whitespace variants around nabla operators so we can
+    # safely do balanced-parenthesis rewrites.
+    expr = re.sub(r"∇\s*[·\*]\s*", "∇·", expr)
+    expr = re.sub(r"∇\s*\(", "∇(", expr)
+
+    # Balanced-parenthesis rewrites for divergence / gradient:
+    #   ∇·( ... )  -> div( ... )   (handles nested parentheses)
+    #   ∇( ... )   -> grad( ... )
+    i = 0
+    while i < len(expr):
+        if expr.startswith("∇·", i):
+            out = _replace_balanced_paren_call(expr, i, "div", op_len=2)
+            if out is not None:
+                expr, i = out
+                continue
+        if expr.startswith("∇(", i):
+            out = _replace_balanced_paren_call(expr, i, "grad", op_len=1)
+            if out is not None:
+                expr, i = out
+                continue
+        i += 1
+
+    # Remove primes like t' -> t
+    expr = re.sub(r"([a-zA-Z_][a-zA-Z0-9_]*)'", r"\1", expr)
+
+    # Normalize partial derivatives BEFORE stripping ∂
+    # Time derivatives in RHS: ∂u/∂t -> u_t, ∂²u/∂t² -> u_tt
+    expr = re.sub(r"∂\s*\^?2\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*/\s*∂t\s*\^?2", r"\1_tt", expr)
+    expr = re.sub(r"∂\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*/\s*∂t", r"\1_t", expr)
+    expr = re.sub(r"∂x\s*\(\s*∂x\s*\(([^\)]*)\)\s*\)", r"dxx(\1)", expr)
+    expr = re.sub(r"∂z\s*\(\s*∂z\s*\(([^\)]*)\)\s*\)", r"dzz(\1)", expr)
+    expr = re.sub(r"∂x\s*\(", "dx(", expr)
+    expr = re.sub(r"∂z\s*\(", "dz(", expr)
+
+    # Positive part: (x)⁺ or x⁺ -> pos(x)
+    expr = re.sub(r"\(([^\)]+)\)\s*⁺", r"pos(\1)", expr)
+    expr = re.sub(r"([a-zA-Z_][a-zA-Z0-9_]*)\s*⁺", r"pos(\1)", expr)
+
+    # Apply direct symbol replacement
+    for k, v in SYMBOL_MAP.items():
+        expr = expr.replace(k, v)
+
+    # Fix concatenated greek-constant prefixes such as "alphasin(u)" or "betau**3".
+    greek_words = (
+        "alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lam|mu|nu|xi|"
+        "omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega"
+    )
+    fn_words = "sin|cos|tan|sinh|cosh|tanh|exp|log|log10|log2|sqrt|abs|sech|sign"
+    expr = re.sub(rf"\b({greek_words})(?=({fn_words})\b)", r"\1*", expr)
+    # Greek word directly followed by a single-letter variable (e.g., beta u)
+        # Greek word directly followed by a single-letter variable (e.g., beta u) or concatenated (betau).
+    # BUT do not split axis-suffixed coefficients like alphax/alphaz (common in anisotropic diffusion terms).
+    _axis_coeffs = {
+        "alphax", "alphaz", "betax", "betaz", "gammax", "gammaz", "deltax", "deltaz",
+        "sigmax", "sigmaz", "thetax", "thetaz", "kappax", "kappaz", "lambdax", "lambdaz",
+        "rhox", "rhoz", "mux", "muz", "nux", "nuz",
+    }
+
+    def _split_greek_letter_var(m: re.Match) -> str:
+        greek = m.group(1)
+        letter = m.group(2)
+        combined = f"{greek}{letter}"
+        if combined in _axis_coeffs:
+            return combined
+        return f"{greek}*{letter}"
+
+    expr = re.sub(rf"({greek_words})([A-Za-z])", _split_greek_letter_var, expr)
+
+    # Absolute value for variables/parentheses
+    expr = re.sub(r"\|\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\|", r"abs(\1)", expr)
+    expr = re.sub(r"\|\s*\(([^\)]*)\)\s*\|", r"abs(\1)", expr)
+
+    # |∇u| -> sqrt(gradmag(u))
+    expr = re.sub(r"\|\s*∇\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\|", r"sqrt(gradmag(\1))", expr)
+
+    # Catch-all for remaining absolute-value bars like |lap(u)|
+    expr = re.sub(r"\|([^|]+)\|", r"abs(\1)", expr)
+
+    # Apply regex-based transformations
+    for pattern, repl in REGEX_RULES:
+        expr = re.sub(pattern, repl, expr)
+
+    # Handle ∇**2 and nested ∇**2
+    prev = None
+    while prev != expr:
+        prev = expr
+        expr = re.sub(r"∇\s*\*\*\s*2\s*\(([^\)]*)\)", r"lap(\1)", expr)
+        expr = re.sub(r"∇\s*\*\*\s*2\s*([a-zA-Z_][a-zA-Z0-9_]*)", r"lap(\1)", expr)
+
+    # Interpret ∇²u³ as lap(u**3)
+    expr = re.sub(r"∇²\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\*\*\s*3", r"lap((\1)**3)", expr)
+    expr = re.sub(r"∇²\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*³", r"lap((\1)**3)", expr)
+    # If lap(u)**3 appears, interpret as lap(u**3)
+    expr = re.sub(r"lap\(([^\)]+)\)\s*\*\*\s*3", r"lap((\1)**3)", expr)
+
+    # Fix nested laplacian call pattern: lap(lap)(u) -> lap(lap(u))
+    expr = re.sub(r"lap\(\s*lap\s*\)\s*\(([^\)]*)\)", r"lap(lap(\1))", expr)
+
+    # Implicit multiplication: 2mu -> 2*mu, )u -> )*u, u( -> u*(
+    # Avoid breaking scientific notation like 1e-9.
+    expr = re.sub(r"(\d)\s*(?![eE][+-]?\d)([a-zA-Z_])", r"\1*\2", expr)
+    expr = re.sub(r"(\d)\s*(\()", r"\1*\2", expr)
+    expr = re.sub(r"(\))\s*([a-zA-Z_])", r"\1*\2", expr)
+    # Symbol followed by operator function: eta lap(u) -> eta*lap(u)
+    expr = re.sub(
+        r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(lap|grad|div|dx|dz|dxx|dzz|pos|gradl1|gradmag)\s*\(",
+        r"\1*\2(",
+        expr,
+    )
+
+    # Fix accidental insertions like gradl1*(u) -> gradl1(u)
+    expr = re.sub(r"\b(gradl1|gradmag|lap|dx|dz|dxx|dzz|grad|div|pos)\s*\*\s*\(", r"\1(", expr)
+    # Avoid inserting * for known functions
+    def _fn_mul(match):
+        name = match.group(1)
+        if name in {
+            "sin", "cos", "tan",
+            "sinh", "cosh", "tanh",
+            "arcsin", "arccos", "arctan",
+            "exp", "sqrt",
+            "log", "log10", "log2",
+            "abs", "sech", "sign",
+            "lap", "dx", "dz", "dxx", "dzz", "grad", "div", "gradmag", "gradl1", "pos",
+        }:
+            return f"{name}("
+        return f"{name}*("
+
+    expr = re.sub(r"([a-zA-Z_][a-zA-Z0-9_]*)\(", _fn_mul, expr)
+
+    return expr
+
+
+def normalize_lhs(expr: str) -> str:
+    if not expr:
+        return ""
+    for k, v in LHS_SYMBOL_MAP.items():
+        expr = expr.replace(k, v)
+    return expr