Fix review findings and bump version to 0.11.0

Security
- Escape error messages in the static diagram view (reflected XSS via
?vals=... with autorun on page load).
- KaTeX trust disabled; escape ids in HTML attributes; textContent for
mount errors; guard against "</script" when inlining the bundle.

Correctness
- abs() differentiable in the scalar engine (real-valued slot symbols).
- x**c at x=0 with 0<c<1 no longer reports derivative 0 (now +inf).
- Shared IEEE/PyTorch numeric policy for both engines: infinite limits
are shown, undefined values (NaN, non-real) raise readable errors
naming the quantity.
- Interactive payload is strict JSON (inf/nan encoded as strings).

Features
- Tensor engine supports sin, cos, tan, sqrt, sinh, cosh, asin, acos,
atan, abs, ln (element-wise); engine dispatch derived from the
tensor-only function set; booleans rejected in both engines.
- URL loading defaults to and autoruns the Interactive tab.
- Keyboard/screen-reader support in the interactive graph; remount when
the payload changes; KaTeX CSS version follows the bundled KaTeX.
- Queue concurrency limit (AUTODIFF_CONCURRENCY_LIMIT, default 16) so
slow mermaid.ink calls do not serialize all users.

Maintenance
- limits.py centralizes limits and the bounded AST validator; drop
deprecated ast.Num handling; app.py cleanup (HfFolder shim, dead code,
shared mermaid.ink fetch helper, API endpoints in a loop).
- renderGraph split into phase methods; unused payload fields removed.
- New tests/test_numeric_policy.py, URL tests, requirements-dev.txt;
docs updated.

README.md

@@ -60,6 +60,15 @@ python -m pip install -r requirements.txt
 python app.py
 ```
 
+Run the tests with:
+
+```sh
+python -m pip install -r requirements-dev.txt
+python -m pytest
+```
+
+The interactive graph is a TypeScript bundle committed as `assets/interactive_graph.bundle.js`. After changing `frontend/src`, rebuild it with `cd frontend && npm ci && npm run build`.
+
 The example tables include toy calculus, regression, classification, hidden layers, attention, pooling, and regularization. Each example loads an explanation and defaults to Forward & Backward. Editing the expression replaces its explanation with an AST-based description.
 
 ## Vector and matrix examples
@@ -77,7 +86,7 @@ Use scalar, vector, or rectangular matrix input assignments, for example `W=[[1,
 
 ## Rendering and exports
 
-Preview, SVG, PNG, and PDF use Mermaid Ink with compressed payloads. Diagram content is sent to that service. Section-title positions use a preliminary SVG measurement and are shared across preview and export; if that request fails, title spacing is retained. Other Mermaid editors may not apply custom title placement.
+The static diagram preview and its SVG, PNG, and PDF exports use the external [Mermaid Ink](https://mermaid.ink) service with compressed payloads, so diagram content (including your expression and values) is sent to that service and these features need network access. The interactive graph, the walkthrough, and the Mermaid/TikZ source exports work offline. Set `AUTODIFF_MERMAID_TIMEOUT` (seconds, default 15) to bound each request. Up to `AUTODIFF_CONCURRENCY_LIMIT` requests (default 16) are processed in parallel, so slow Mermaid Ink responses do not block other users. Section-title positions use a preliminary SVG measurement and are shared across preview and export; if that request fails, title spacing is retained. Other Mermaid editors may not apply custom title placement.
 
 ## Python and Notebook API
 

app.py

@@ -1,12 +1,3 @@
-import huggingface_hub
-if not hasattr(huggingface_hub, 'HfFolder'):
-    class HfFolder:
-        @classmethod
-        def get_token(cls): return None
-        @classmethod
-        def save_token(cls, token): pass
-    huggingface_hub.HfFolder = HfFolder
-
 import os
 import re
 import time
@@ -20,9 +11,9 @@ import html as html_lib
 from pathlib import Path
 import gradio as gr
 import sympy as sp
-from autodiff_visualizer import ComputationGraph, safe_parse_expr
+from autodiff_visualizer import ComputationGraph, safe_parse_expr, ALLOWED_FUNCS as SCALAR_ALLOWED_FUNCS
 
-__version__ = "0.10.0"
+__version__ = "0.11.0"
 __version_date__ = "2026-11-04"
 __status__ = "Beta"
 
@@ -38,7 +29,6 @@ if _ex_start != -1 and _ex_end != -1:
 else:
     VISUAL_LANGUAGE_HELP = VISUAL_LANGUAGE_RAW
     EXAMPLES_MD = ""
-VISUAL_LANGUAGE = VISUAL_LANGUAGE_HELP
 
 TUTORIAL_EXERCISES = [
     ['(x * x) * y + (y + 2)', 'x=3, y=4', 'Exercise 1: Multi-Path Gradient Accumulation'],
@@ -118,7 +108,7 @@ def prune_cache(max_files=60, max_age_seconds=3600):
 
 
 from input_parser import parse_variable_assignments
-from tensor_engine import TensorComputationGraph
+from tensor_engine import TensorComputationGraph, TENSOR_ALLOWED_FUNCS
 from diagram_layout import with_title_layout, encode_mermaid
 from formula_explanation import explain_formula
 import numpy as np
@@ -129,13 +119,31 @@ from interactive_renderer import render_interactive_html
 from number_format import NumberFormatConfig
 
 _INTERACTIVE_BUNDLE_PATH = Path(__file__).with_name("assets") / "interactive_graph.bundle.js"
+if not _INTERACTIVE_BUNDLE_PATH.exists():
+    print(f"Warning: {_INTERACTIVE_BUNDLE_PATH} is missing; run `npm run build` in frontend/. "
+          "The interactive graph tab will stay empty.")
 INTERACTIVE_GRAPH_SCRIPT = (
-    "<script>\n" + _INTERACTIVE_BUNDLE_PATH.read_text(encoding="utf8") + "\n</script>"
+    # A literal "</script" would close the inline tag early; "<\/script" is
+    # equivalent inside JS strings, template literals and regexes.
+    "<script>\n" + re.sub(r"</(script)", r"<\\/\1", _INTERACTIVE_BUNDLE_PATH.read_text(encoding="utf8"),
+                          flags=re.IGNORECASE) + "\n</script>"
     if _INTERACTIVE_BUNDLE_PATH.exists()
     else ""
 )
 
 
+# Functions only the tensor engine provides. Everything the scalar engine
+# supports (except variable exponents such as x**y) works in both engines.
+_TENSOR_ONLY_FUNCS = sorted(TENSOR_ALLOWED_FUNCS - set(SCALAR_ALLOWED_FUNCS))
+_TENSOR_SYNTAX_RE = re.compile(r"@|\[|\b(?:" + "|".join(_TENSOR_ONLY_FUNCS) + r")\s*\(")
+
+
+def uses_tensor_engine(expr_str, feed):
+    """Scalar SymPy engine unless the inputs or the syntax require tensors."""
+    has_tensor_input = any(isinstance(v, np.ndarray) and v.ndim >= 1 for v in feed.values())
+    return has_tensor_input or bool(_TENSOR_SYNTAX_RE.search(expr_str))
+
+
 def build_model_from_inputs(expr_str, values_str, mode):
     """Builds ComputationModel using identical logic for diagram and trace renderers."""
     if not expr_str or not expr_str.strip():
@@ -145,10 +153,7 @@ def build_model_from_inputs(expr_str, values_str, mode):
     forward_only = (mode == "Forward Only")
     parsed_feed = parse_variable_assignments(values_str)
 
-    has_tensor_input = any(isinstance(v, np.ndarray) and v.ndim >= 1 for v in parsed_feed.values())
-    has_tensor_syntax = bool(re.search(r'(@|\bdot\b|\bsum\b|\bmean\b|\bsigmoid\b|\brelu\b|\bmax\b|\bmin\b|\bsoftmax\b|\bpick\b|\[)', cleaned_expr))
-
-    if has_tensor_input or has_tensor_syntax:
+    if uses_tensor_engine(cleaned_expr, parsed_feed):
         cg = TensorComputationGraph()
         cg.build_from_ast(cleaned_expr)
         cg.evaluate(parsed_feed, forward_only=forward_only)
@@ -164,7 +169,6 @@ def build_model_from_inputs(expr_str, values_str, mode):
 def export_tikz_from_inputs(expr_str, values_str, mode, precision=2):
     """Export a compact, editable slide diagram from the current inputs."""
     from tikz_renderer import render_tikz_document
-    import tempfile
     try:
         model = build_model_from_inputs(expr_str, values_str, mode)
         source = render_tikz_document(model, precision=precision)
@@ -217,32 +221,22 @@ def generate_diagram(expr_str, values_str, mode, notation="∂(...) / ∂x [Math
         raw_mermaid_code = mermaid_code
         mermaid_code = with_title_layout(raw_mermaid_code)
         try:
-            layout_payload = encode_mermaid(mermaid_code)
-            request = urllib.request.Request(
-                f"https://mermaid.ink/svg/{layout_payload}",
-                headers={"User-Agent": "Mozilla/5.0"},
-            )
-            with urllib.request.urlopen(request, timeout=15) as response:
-                mermaid_code = with_title_layout(raw_mermaid_code, response.read())
+            layout_svg = fetch_mermaid_ink("svg", encode_mermaid(mermaid_code))
+            mermaid_code = with_title_layout(raw_mermaid_code, layout_svg)
         except Exception as error:
             print("Warning: Could not position section titles; retaining title spacing:", error)
 
         # Encode for mermaid.ink
         base64_string = encode_mermaid(mermaid_code)
-
-        png_url = f"https://mermaid.ink/img/{base64_string}?type=png"
+        png_url = MERMAID_INK_URLS["png"].format(payload=base64_string)
         b64_png = None
 
-        headers = {"User-Agent": "Mozilla/5.0"}
-
         # Only fetch PNG needed for responsive HTML display
         try:
-            req_png = urllib.request.Request(png_url, headers=headers)
-            with urllib.request.urlopen(req_png, timeout=15) as resp:
-                png_data = resp.read()
-                with open(png_path, "wb") as f:
-                    f.write(png_data)
-                b64_png = base64.b64encode(png_data).decode("ascii")
+            png_data = fetch_mermaid_ink("png", base64_string)
+            with open(png_path, "wb") as f:
+                f.write(png_data)
+            b64_png = base64.b64encode(png_data).decode("ascii")
         except Exception as e:
             print("Warning: Could not fetch PNG preview:", e)
 
@@ -263,95 +257,84 @@ def generate_diagram(expr_str, values_str, mode, notation="∂(...) / ∂x [Math
         return html, mermaid_code
 
     except Exception as e:
-        error_html = f"<div style='color: #e53e3e; background: #fff5f5; padding: 15px; border-radius: 8px; border: 1px solid #feb2b2;'><b>Error:</b> {str(e)}</div>"
+        error_html = f"<div style='color: #e53e3e; background: #fff5f5; padding: 15px; border-radius: 8px; border: 1px solid #feb2b2;'><b>Error:</b> {html_lib.escape(str(e))}</div>"
         return error_html, ""
 
 
 
 
+MERMAID_INK_URLS = {
+    "svg": "https://mermaid.ink/svg/{payload}",
+    "png": "https://mermaid.ink/img/{payload}?type=png",
+    "pdf": "https://mermaid.ink/pdf/{payload}",
+}
+MERMAID_INK_TIMEOUT = float(os.environ.get("AUTODIFF_MERMAID_TIMEOUT", "15"))
+
+
+def fetch_mermaid_ink(kind, payload):
+    """Render encoded Mermaid source with the external mermaid.ink service.
+
+    The static diagram and its PNG/SVG/PDF exports depend on this service (the
+    interactive graph, walkthrough and TikZ export do not). Raises on failure.
+    """
+    request = urllib.request.Request(
+        MERMAID_INK_URLS[kind].format(payload=payload), headers={"User-Agent": "Mozilla/5.0"}
+    )
+    with urllib.request.urlopen(request, timeout=MERMAID_INK_TIMEOUT) as response:
+        chunks = []
+        while True:
+            try:
+                chunk = response.read(65536)
+            except Exception as error:  # e.g. IncompleteRead: keep what arrived
+                if getattr(error, "partial", None):
+                    chunks.append(error.partial)
+                break
+            if not chunk:
+                break
+            chunks.append(chunk)
+    data = b"".join(chunks)
+    if not data:
+        raise OSError(f"mermaid.ink returned an empty {kind} response")
+    return data
+
+
 def export_file(mermaid_code, fmt):
     """Generates the requested export format on demand with content hashing and cache."""
     if not mermaid_code or not mermaid_code.strip():
         return None, gr.update(visible=False)
-    
+
     prune_cache()
-    graphbytes = mermaid_code.encode("utf8")
-    b64 = encode_mermaid(mermaid_code)
-    code_hash = hashlib.md5(graphbytes).hexdigest()[:12]
+    code_hash = hashlib.md5(mermaid_code.encode("utf8")).hexdigest()[:12]
     out_path = os.path.join(CACHE_DIR, f"autodiff_{code_hash}.{fmt}")
-    
+
     if os.path.exists(out_path) and os.path.getsize(out_path) > 0:
         return out_path, gr.update(value=out_path, visible=True)
-    
-    headers = {"User-Agent": "Mozilla/5.0"}
-    
-    def safe_read(resp):
-        chunks = []
-        while True:
-            try:
-                c = resp.read(65536)
-                if not c:
-                    break
-                chunks.append(c)
-            except Exception as re_err:
-                if hasattr(re_err, 'partial') and re_err.partial:
-                    chunks.append(re_err.partial)
-                break
-        return b"".join(chunks)
 
-    if fmt == "pdf":
-        url = f"https://mermaid.ink/pdf/{b64}"
-        try:
-            req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=15) as resp:
-                data = safe_read(resp)
-                if data:
-                    with open(out_path, "wb") as f:
-                        f.write(data)
-                    return out_path, gr.update(value=out_path, visible=True)
-        except Exception as e:
-            print("Warning: Native PDF export failed, trying Pillow fallback:", e)
-            png_path, _ = export_file(mermaid_code, "png")
-            if png_path and os.path.exists(png_path):
-                try:
-                    from PIL import Image
-                    img = Image.open(png_path).convert("RGB")
-                    img.save(out_path, "PDF", resolution=300)
-                    return out_path, gr.update(value=out_path, visible=True)
-                except Exception as pe:
-                    print("Pillow PDF conversion failed:", pe)
-    elif fmt == "png":
-        url = f"https://mermaid.ink/img/{b64}?type=png"
-        try:
-            req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=15) as resp:
-                data = safe_read(resp)
-                if data:
-                    with open(out_path, "wb") as f:
-                        f.write(data)
-                    return out_path, gr.update(value=out_path, visible=True)
-        except Exception as e:
-            print("Warning: PNG export failed:", e)
-    elif fmt == "svg":
-        url = f"https://mermaid.ink/svg/{b64}"
-        try:
-            req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=15) as resp:
-                data = safe_read(resp)
-                if data:
-                    with open(out_path, "wb") as f:
-                        f.write(data)
-                    return out_path, gr.update(value=out_path, visible=True)
-        except Exception as e:
-            print("Warning: SVG export failed:", e)
-    elif fmt == "mmd":
-        try:
+    try:
+        if fmt == "mmd":
             with open(out_path, "w", encoding="utf-8") as f:
                 f.write(mermaid_code)
-            return out_path, gr.update(value=out_path, visible=True)
-        except Exception as e:
-            print("Warning: Mermaid export failed:", e)
-            
+        elif fmt in MERMAID_INK_URLS:
+            data = fetch_mermaid_ink(fmt, encode_mermaid(mermaid_code))
+            with open(out_path, "wb") as f:
+                f.write(data)
+        else:
+            raise ValueError(f"Unsupported export format: {fmt}")
+        return out_path, gr.update(value=out_path, visible=True)
+    except Exception as e:
+        print(f"Warning: {fmt.upper()} export failed:", e)
+
+    if fmt == "pdf":
+        # Fallback: rasterise the PNG export into a PDF.
+        png_path, _ = export_file(mermaid_code, "png")
+        if png_path and os.path.exists(png_path):
+            try:
+                from PIL import Image
+                Image.open(png_path).convert("RGB").save(out_path, "PDF", resolution=300)
+                return out_path, gr.update(value=out_path, visible=True)
+            except Exception as pe:
+                print("Pillow PDF conversion failed:", pe)
+
     return None, gr.update(visible=False)
 
 
@@ -375,29 +358,6 @@ def api_generate_mermaid(expr_str: str, values_str: str, mode: str = "Forward &
 
 
 
-def build_visual_grammar_html():
-    """Use the actual renderer for help samples, keeping labels in sync."""
-    from diagram_renderer import quantity_label, step_label, backward_edge_label
-    from teaching_examples import multiplication_example
-    model = multiplication_example()
-    q = next(q for q in model.quantities if q.name == "n1")
-    op = next(op for op in model.operations if op.quantity is q)
-    step = next(step for step in model.steps if step.source_quantity is q)
-    intro = next(e for e in model.backward_edges if e.quantity and e.quantity.name == "x" and e.kind.name == "ADJOINT_INTRODUCTION")
-    samples = [
-        ("Quantity stores two results", quantity_label(q, op, "mathbook"),
-         "Above the divider: primal value. Below: accumulated adjoint."),
-        ("Backward step applies a rule", step_label(step, "mathbook"),
-         "Above: local rule for this operand occurrence. Below: its numerical chain-rule application."),
-        ("Arrows carry information", "12 → Σ ← 12<br>Σ → " + backward_edge_label(intro, model, "mathbook"),
-         "Green arrows carry primal numbers. Purple arrows carry named adjoints or numerical contributions. Σ adds contributions before introducing the adjoint."),
-    ]
-    return '<div style="display:flex;flex-wrap:wrap;gap:16px">' + "".join(
-        f'<div style="flex:1;min-width:250px;padding:16px;border:1px solid #aaa;border-radius:12px">'
-        f'<strong>{title}</strong><div style="text-align:center;padding:16px;background:#f4eef6;color:#42254d">{label}</div><p>{description}</p></div>'
-        for title, label, description in samples) + '</div>'
-
-
 APP_STYLE = """
 /* ==========================================================================
    Problem editor & Formula explanation
@@ -896,60 +856,30 @@ with gr.Blocks(title="Autodiff Visualizer") as demo:
     # -------------------------------------------------------------------------
     # Public API Endpoints for Jupyter Notebooks, external scripts, & clients
     # -------------------------------------------------------------------------
-    api_btn_png = gr.Button(visible=False)
-    api_file_png = gr.File(visible=False)
-    api_btn_png.click(
-        fn=lambda expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True: (
-            api_generate_file(expr, vals, mode, notation, "png", precision=precision, allow_scientific=allow_scientific)
-        ),
-        inputs=[expr_input, vals_input, mode_input, notation_input, precision_input, scientific_input],
-        outputs=api_file_png,
-        api_name="generate_png",
-    )
+    api_inputs = [expr_input, vals_input, mode_input, notation_input, precision_input, scientific_input]
 
-    api_btn_svg = gr.Button(visible=False)
-    api_file_svg = gr.File(visible=False)
-    api_btn_svg.click(
-        fn=lambda expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True: (
-            api_generate_file(expr, vals, mode, notation, "svg", precision=precision, allow_scientific=allow_scientific)
-        ),
-        inputs=[expr_input, vals_input, mode_input, notation_input, precision_input, scientific_input],
-        outputs=api_file_svg,
-        api_name="generate_svg",
-    )
+    def _api_file_endpoint(fmt):
+        def endpoint(expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True):
+            return api_generate_file(expr, vals, mode, notation, fmt, precision=precision, allow_scientific=allow_scientific)
+        return endpoint
 
-    api_btn_pdf = gr.Button(visible=False)
-    api_file_pdf = gr.File(visible=False)
-    api_btn_pdf.click(
-        fn=lambda expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True: (
-            api_generate_file(expr, vals, mode, notation, "pdf", precision=precision, allow_scientific=allow_scientific)
-        ),
-        inputs=[expr_input, vals_input, mode_input, notation_input, precision_input, scientific_input],
-        outputs=api_file_pdf,
-        api_name="generate_pdf",
-    )
+    def _api_mermaid_endpoint(expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True):
+        return api_generate_mermaid(expr, vals, mode, notation, precision=precision, allow_scientific=allow_scientific)
 
-    api_btn_mermaid = gr.Button(visible=False)
-    api_code_mermaid = gr.Code(visible=False)
-    api_btn_mermaid.click(
-        fn=lambda expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True: (
-            api_generate_mermaid(expr, vals, mode, notation, precision=precision, allow_scientific=allow_scientific)
-        ),
-        inputs=[expr_input, vals_input, mode_input, notation_input, precision_input, scientific_input],
-        outputs=api_code_mermaid,
-        api_name="generate_mermaid",
-    )
+    def _api_walkthrough_endpoint(expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True):
+        return generate_trace(expr, vals, mode, notation, precision=precision, allow_scientific=allow_scientific)
 
-    api_btn_walkthrough = gr.Button(visible=False)
-    api_html_walkthrough = gr.HTML(visible=False)
-    api_btn_walkthrough.click(
-        fn=lambda expr, vals, mode="Forward & Backward", notation="∂(...) / ∂x [Mathbook]", precision=2, allow_scientific=True: (
-            generate_trace(expr, vals, mode, notation, precision=precision, allow_scientific=allow_scientific)
-        ),
-        inputs=[expr_input, vals_input, mode_input, notation_input, precision_input, scientific_input],
-        outputs=api_html_walkthrough,
-        api_name="generate_walkthrough",
-    )
+    api_endpoints = [
+        ("generate_png", _api_file_endpoint("png"), gr.File),
+        ("generate_svg", _api_file_endpoint("svg"), gr.File),
+        ("generate_pdf", _api_file_endpoint("pdf"), gr.File),
+        ("generate_mermaid", _api_mermaid_endpoint, gr.Code),
+        ("generate_walkthrough", _api_walkthrough_endpoint, gr.HTML),
+    ]
+    for api_name, endpoint, output_cls in api_endpoints:
+        gr.Button(visible=False).click(
+            fn=endpoint, inputs=api_inputs, outputs=output_cls(visible=False), api_name=api_name,
+        )
 
     # -------------------------------------------------------------------------
     # URL Query Parameter Loading (e.g. ?expr=...&vals=...&tab=...)
@@ -957,7 +887,7 @@ with gr.Blocks(title="Autodiff Visualizer") as demo:
     def load_from_request(request: gr.Request):
         params = request.query_params if request else {}
         if not params:
-            return (gr.skip(),) * 11
+            return (gr.skip(),) * 12
 
         expr_param = (params.get("expr") or params.get("formula") or "").strip()
         vals_param = (params.get("vals") or params.get("values") or "").strip()
@@ -977,10 +907,11 @@ with gr.Blocks(title="Autodiff Visualizer") as demo:
             target_tab = "tab_tutorial"
         elif tab_param in {"help", "guide", "user_guide", "tab_help"}:
             target_tab = "tab_help"
-        elif tab_param in {"diagram", "visual", "tab_diagram"} or expr_param:
+        elif tab_param in {"diagram", "static", "mermaid", "visual", "tab_diagram"}:
             target_tab = "tab_diagram"
         else:
-            target_tab = "tab_diagram"
+            # Default matches the app's initial tab.
+            target_tab = "tab_interactive"
 
         # Expressions and values
         expr_up = expr_param if expr_param else gr.skip()
@@ -1029,6 +960,7 @@ with gr.Blocks(title="Autodiff Visualizer") as demo:
         diagram_html_up = gr.skip()
         mermaid_code_up = gr.skip()
         trace_html_up = gr.skip()
+        interactive_html_up = gr.skip()
 
         if do_autorun and expr_param:
             eff_vals = vals_param if vals_param else ""
@@ -1037,24 +969,13 @@ with gr.Blocks(title="Autodiff Visualizer") as demo:
             eff_precision = precision_val
             eff_sci = sci_up if sci_up is not gr.skip() else True
 
+            run_args = (expr_param, eff_vals, eff_mode, eff_notation, eff_precision, eff_sci)
             if target_tab == "tab_trace":
-                trace_html_up = on_generate_trace(
-                    eff_expr := expr_param,
-                    eff_vals,
-                    eff_mode,
-                    eff_notation,
-                    eff_precision,
-                    eff_sci,
-                )
+                trace_html_up = on_generate_trace(*run_args)
+            elif target_tab == "tab_diagram":
+                diagram_html_up, mermaid_code_up = on_generate_diagram(*run_args)
             else:
-                diagram_html_up, mermaid_code_up = on_generate_diagram(
-                    eff_expr := expr_param,
-                    eff_vals,
-                    eff_mode,
-                    eff_notation,
-                    eff_precision,
-                    eff_sci,
-                )
+                interactive_html_up = on_generate_interactive(*run_args)
 
         return (
             gr.Tabs(selected=target_tab),
@@ -1068,6 +989,7 @@ with gr.Blocks(title="Autodiff Visualizer") as demo:
             diagram_html_up,
             mermaid_code_up,
             trace_html_up,
+            interactive_html_up,
         )
 
     load_outputs = [
@@ -1082,9 +1004,18 @@ with gr.Blocks(title="Autodiff Visualizer") as demo:
         diagram_output,
         code_output,
         trace_output,
+        interactive_output,
     ]
     demo.load(load_from_request, inputs=None, outputs=load_outputs, api_name=False)
 
 
+# Gradio runs each event one request at a time by default. Static diagrams wait
+# on mermaid.ink (network I/O, up to two requests per click), so a classroom of
+# simultaneous clicks would otherwise queue behind each other. Handlers run in
+# worker threads; the engines keep no shared mutable state between requests.
+CONCURRENCY_LIMIT = int(os.environ.get("AUTODIFF_CONCURRENCY_LIMIT", "16"))
+demo.queue(default_concurrency_limit=CONCURRENCY_LIMIT)
+
+
 if __name__ == "__main__":
     demo.launch(head=APP_HEAD, css=APP_STYLE)

autodiff_visualizer.py

@@ -1,8 +1,14 @@
 import ast
 import math
 import re
+import numpy as np
 import sympy as sp
 from number_format import format_num, format_numeric_literals
+from limits import (
+    BoundedASTValidator, MAX_AST_DEPTH, MAX_AST_NODES, MAX_EXPR_LEN, MAX_NUMERIC_MAGNITUDE,
+    MAX_EXPONENT_MAGNITUDE,
+    VARIABLE_NAME_PATTERN,
+)
 
 # ---------------------------------------------------------------------------
 # 1. Safe AST-Based Mathematical Parser (No eval, No sympify)
@@ -23,7 +29,8 @@ class nograd(sp.Function):
 
 
 # sp.lambdify has no built-in translation for our custom nograd Function.
-LAMBDIFY_MODULES = [{"nograd": lambda v: v}, "math"]
+# NumPy (rather than math) gives IEEE semantics: log(0) = -inf, log(-1) = nan.
+LAMBDIFY_MODULES = [{"nograd": lambda v: v}, "numpy"]
 
 ALLOWED_FUNCS = {
     "sin": sp.sin,
@@ -44,59 +51,10 @@ ALLOWED_FUNCS = {
     "nograd": nograd,
 }
 
-MAX_EXPR_LEN = 200
-MAX_AST_NODES = 250
-MAX_AST_DEPTH = 35
-MAX_NUMERIC_MAGNITUDE = 1e9
-MAX_EXPONENT_MAGNITUDE = 50
 
 
-class ASTValidator(ast.NodeVisitor):
-    def __init__(self):
-        self.node_count = 0
-        self.max_depth = 0
-        self.current_depth = 0
-
-    def visit(self, node):
-        self.node_count += 1
-        if self.node_count > MAX_AST_NODES:
-            raise ValueError(f"Expression exceeds complexity limit ({MAX_AST_NODES} nodes).")
-        
-        self.current_depth += 1
-        if self.current_depth > self.max_depth:
-            self.max_depth = self.current_depth
-        if self.max_depth > MAX_AST_DEPTH:
-            raise ValueError(f"Expression nesting too deep (max depth {MAX_AST_DEPTH}).")
-            
-        res = super().visit(node)
-        self.current_depth -= 1
-        return res
-
-    def generic_visit(self, node):
-        # Disallow any unsupported AST node types
-        allowed_types = (
-            ast.Expression,
-            ast.BinOp,
-            ast.UnaryOp,
-            ast.Add,
-            ast.Sub,
-            ast.Mult,
-            ast.Div,
-            ast.Pow,
-            ast.UAdd,
-            ast.USub,
-            ast.Name,
-            ast.Constant,
-            ast.Call,
-            ast.Load,
-        )
-        # Compatibility with Python < 3.8
-        if hasattr(ast, "Num"):
-            allowed_types = allowed_types + (ast.Num,)
-
-        if not isinstance(node, allowed_types):
-            raise ValueError(f"Disallowed construct: {type(node).__name__}")
-        super().generic_visit(node)
+class ASTValidator(BoundedASTValidator):
+    """Scalar grammar: arithmetic, names, numbers and allowlisted calls."""
 
 
 def ast_to_sympy(node):
@@ -104,19 +62,16 @@ def ast_to_sympy(node):
         return ast_to_sympy(node.body)
 
     if isinstance(node, ast.Constant):
+        if isinstance(node.value, bool):
+            raise ValueError("Boolean constants are not allowed.")
         if not isinstance(node.value, (int, float)):
             raise ValueError(f"Only numeric constants are allowed, got: {type(node.value).__name__}")
         if abs(node.value) > MAX_NUMERIC_MAGNITUDE:
             raise ValueError(f"Numeric constant {node.value} exceeds maximum allowed magnitude ({MAX_NUMERIC_MAGNITUDE}).")
         return sp.Number(node.value)
 
-    if hasattr(ast, "Num") and isinstance(node, ast.Num):
-        if abs(node.n) > MAX_NUMERIC_MAGNITUDE:
-            raise ValueError(f"Numeric constant {node.n} exceeds maximum allowed magnitude.")
-        return sp.Number(node.n)
-
     if isinstance(node, ast.Name):
-        if not re.match(r"^[a-zA-Z][a-zA-Z0-9_]*$", node.id):
+        if not re.match(VARIABLE_NAME_PATTERN, node.id):
             raise ValueError(f"Invalid variable identifier: {node.id}")
         return sp.Symbol(node.id)
 
@@ -214,6 +169,38 @@ def format_mathbook_expr(expr):
 # 3. Graph Nodes & Computation Graph Engine
 # ---------------------------------------------------------------------------
 
+def _real_power(base, exponent):
+    """Real-valued power; integer exponents of negative bases stay real."""
+    if base < 0 and abs(exponent - round(exponent)) < 1e-9:
+        return base ** int(round(exponent))
+    return base ** exponent
+
+
+def _checked_number(compute, description):
+    """Evaluate one numeric step under the policy shared with the tensor engine.
+
+    Arithmetic follows IEEE/NumPy (and PyTorch) conventions: infinite values
+    such as log(0) = -inf or d/dx sqrt(x) at 0 = +inf are legitimate limits and
+    are shown. NaN or non-real results mean the quantity is undefined; they
+    are reported as an error naming the offending quantity.
+    """
+    try:
+        with np.errstate(all="ignore"):
+            value = compute()
+    except ZeroDivisionError:
+        raise ValueError(f"{description} is undefined: 0/0 or a negative power of 0.") from None
+    except (OverflowError, ValueError, TypeError) as exc:
+        raise ValueError(f"{description} cannot be evaluated for these inputs ({exc}).") from None
+    if isinstance(value, complex) or np.iscomplexobj(value):
+        raise ValueError(f"{description} is not a real number (e.g. a fractional power of a negative number).")
+    value = np.float64(value)
+    if np.isnan(value):
+        raise ValueError(
+            f"{description} is undefined (e.g. log or a fractional power of a negative number, 0/0, or inf - inf)."
+        )
+    return value
+
+
 class Node:
     def __init__(self, uid, name, expr, is_input=False, is_constant=False):
         self.uid = uid            # Opaque unique graph identifier (e.g. inp_0, op_1)
@@ -309,7 +296,10 @@ class ComputationGraph:
         node.args = child_nodes
         self.expr_to_node[expr] = node
 
-        dummy_symbols = [sp.Symbol(f"_u{i}") for i in range(len(node.args))]
+        # Inputs are real numbers. Declaring the slots real lets SymPy produce
+        # closed-form derivatives (e.g. d|u|/du = sign(u)) instead of
+        # unevaluable Derivative(re(u)) terms.
+        dummy_symbols = [sp.Symbol(f"_u{i}", real=True) for i in range(len(node.args))]
         if isinstance(expr, sp.Add):
             dummy_op = sp.Add(*dummy_symbols)
         elif isinstance(expr, sp.Mul):
@@ -405,33 +395,47 @@ class ComputationGraph:
         self.nodes.append(node)
         return node
 
+    def _forward_value(self, node):
+        if isinstance(node.expr, sp.Add):
+            return sum(arg.val for arg in node.args)
+        if isinstance(node.expr, sp.Mul):
+            prod = 1.0
+            for arg in node.args:
+                prod *= arg.val
+            return prod
+        if isinstance(node.expr, sp.Pow):
+            return _real_power(node.args[0].val, node.args[1].val)
+        return node.forward_fn(*(arg.val for arg in node.args))
+
+    @staticmethod
+    def _local_derivative_value(node, loc):
+        if loc.get('is_pow_constant_exp', False):
+            c = loc['exp_val']
+            if c == 0:
+                return 0.0  # d/dx x**0 = 0 everywhere, including x = 0
+            # For 0 < c < 1 at x = 0 this raises ZeroDivisionError: the
+            # derivative is unbounded, which must not be reported as 0.
+            return c * _real_power(node.args[0].val, c - 1)
+        if loc.get('is_pow_constant_base', False):
+            c = loc['base_val']
+            return _real_power(np.float64(c), node.args[1].val) * np.log(np.float64(c))
+        return loc['numeric_fn'](*(arg.val for arg in node.args))
+
     def evaluate(self, feed_dict, forward_only=False):
         # 1. Forward pass
         for node in self.nodes:
             if node.is_input:
                 if node.expr in feed_dict:
-                    node.val = float(feed_dict[node.expr])
+                    node.val = np.float64(feed_dict[node.expr])
                 elif node.is_constant:
-                    node.val = float(node.expr)
+                    node.val = np.float64(float(node.expr))
                 else:
                     raise ValueError(f"Missing numerical value for variable '{node.name}'")
             else:
-                if isinstance(node.expr, sp.Add):
-                    node.val = float(sum(arg.val for arg in node.args))
-                elif isinstance(node.expr, sp.Mul):
-                    prod = 1.0
-                    for arg in node.args:
-                        prod *= arg.val
-                    node.val = float(prod)
-                elif isinstance(node.expr, sp.Pow):
-                    base_val = node.args[0].val
-                    exp_val = node.args[1].val
-                    if base_val < 0 and abs(exp_val - round(exp_val)) < 1e-9:
-                        node.val = float(base_val ** int(round(exp_val)))
-                    else:
-                        node.val = float(base_val ** exp_val)
-                else:
-                    node.val = float(node.forward_fn(*(arg.val for arg in node.args)))
+                node.val = _checked_number(
+                    lambda: self._forward_value(node),
+                    f"Value of {node.name} = {format_expr(node.expr)}",
+                )
 
         # If forward only mode, bypass local derivative evaluation and backpropagation
         if forward_only:
@@ -441,21 +445,10 @@ class ComputationGraph:
         for node in self.nodes:
             if not node.is_input:
                 for loc in node.local_derivatives:
-                    if loc.get('is_pow_constant_exp', False):
-                        base_val = node.args[0].val
-                        c = loc['exp_val']
-                        if base_val == 0.0 and c < 1:
-                            loc['local_val'] = 0.0
-                        elif base_val < 0 and abs((c - 1) - round(c - 1)) < 1e-9:
-                            loc['local_val'] = float(c * (base_val ** int(round(c - 1))))
-                        else:
-                            loc['local_val'] = float(c * (base_val ** (c - 1)))
-                    elif loc.get('is_pow_constant_base', False):
-                        c = loc['base_val']
-                        exp_val = node.args[1].val
-                        loc['local_val'] = float((c ** exp_val) * math.log(c))
-                    else:
-                        loc['local_val'] = float(loc['numeric_fn'](*(arg.val for arg in node.args)))
+                    loc['local_val'] = _checked_number(
+                        lambda: self._local_derivative_value(node, loc),
+                        f"Local derivative of {node.name} with respect to {loc['arg_node'].name}",
+                    )
 
         # 3. Backward pass (Accumulate adjoints & record edge contributions)
         for node in self.nodes:
@@ -477,7 +470,10 @@ class ComputationGraph:
                 continue  # hard stop: no backward step, no adjoint edge
             for loc in node.local_derivatives:
                 child = loc['arg_node']
-                contrib = node.grad * loc['local_val']
+                contrib = _checked_number(
+                    lambda: node.grad * loc['local_val'],
+                    f"Gradient contribution from {node.name} to {child.name}",
+                )
                 loc['grad_contrib'] = contrib
                 child.grad += contrib
                 child.live = True

backward_rules.py

@@ -37,6 +37,25 @@ def scalar_rule(operation, occurrence, derivative, slot_derivative=None, slots=(
         derivative, node('mul', adjoint(operation.quantity), derivative), bindings)
 
 
+def _inverse_sqrt_one_minus_square(x):
+    return node('div', literal(1), node('pow', node('sub', literal(1), node('pow', x, literal(2))), literal(0.5)))
+
+
+# Local derivative factors f'(x) for elementwise functions; y = f(x).
+_ELEMENTWISE_FACTORS = {
+    'sin': lambda x, y, prod: node('cos', x),
+    'cos': lambda x, y, prod: node('neg', node('sin', x)),
+    'tan': lambda x, y, prod: node('add', literal(1), node('pow', y, literal(2))),
+    'sqrt': lambda x, y, prod: node('div', literal(1), node('mul', literal(2), y)),
+    'sinh': lambda x, y, prod: node('cosh', x),
+    'cosh': lambda x, y, prod: node('sinh', x),
+    'asin': lambda x, y, prod: _inverse_sqrt_one_minus_square(x),
+    'acos': lambda x, y, prod: node('neg', _inverse_sqrt_one_minus_square(x)),
+    'atan': lambda x, y, prod: node('div', literal(1), node('add', literal(1), node('pow', x, literal(2)))),
+    'Abs': lambda x, y, prod: node('sign', x),
+}
+
+
 def tensor_rule(operation, occurrence):
     """Construct one local pullback. Its expression is also its implementation."""
     from scalar_rules import operand_slots
@@ -140,6 +159,10 @@ def tensor_rule(operation, occurrence):
             factor = y
         elif function == 'log':
             factor = node('div', literal(1), x)
+        elif function in _ELEMENTWISE_FACTORS:
+            factor = _ELEMENTWISE_FACTORS[function](x, y, 'elementwise' if child.shape else 'mul')
+            if function == 'Abs':
+                notes = ('sign(x) is -1, 0 or 1; at zero the chosen derivative is 0.',)
         if factor is None:
             raise ValueError(f'Missing backward rule for {kind}/{function}')
         # A zero exponent is constant even if the incoming adjoint is nonfinite.

docs/USER_GUIDE.md

@@ -175,13 +175,12 @@ The visualizer includes both a **scalar calculus engine** and a **vector/matrix
 | Engine | Operators / Functions | Notes & Syntax |
 | :--- | :--- | :--- |
 | **Both** | `+`, `-`, `*`, `/`, unary `-` | Standard arithmetic; array operations are element-wise. |
-| **Both** | `**` | Powers ($x^y$ for scalars, integer/float powers like `v**2` for vectors). |
-| **Both** | `exp`, `log`, `tanh` | Natural exponential, natural logarithm, hyperbolic tangent. |
+| **Both** | `**` | Powers. $x^y$ with a variable exponent requires all inputs to be scalars; vectors and matrices need a constant exponent such as `v**2`. |
+| **Both** | `exp`, `log`/`ln`, `sqrt` | Natural exponential, natural logarithm, square root (element-wise on arrays). |
+| **Both** | `sin`, `cos`, `tan`, `asin`, `acos`, `atan` | Trigonometric and inverse trigonometric functions (radians, element-wise). |
+| **Both** | `sinh`, `cosh`, `tanh` | Hyperbolic functions (element-wise). |
+| **Both** | `abs` | Absolute value; its derivative is `sign(x)`, with 0 chosen at $x = 0$. |
 | **Both** | `nograd(x)` | Stops backward gradient propagation through $x$. |
-| **Scalar only** | `sin`, `cos`, `tan` | Trigonometric functions (radians). |
-| **Scalar only** | `asin`, `acos`, `atan` | Inverse trigonometric functions. |
-| **Scalar only** | `sinh`, `cosh` | Hyperbolic sine and cosine. |
-| **Scalar only** | `sqrt`, `ln`, `abs` | Square root, natural log, absolute value. |
 | **Tensor only** | `@` | Matrix multiplication, matrix-vector product, vector dot product. |
 | **Tensor only** | `dot(u, v)` | Dot product of two vectors of equal length. |
 | **Tensor only** | `sum(x)`, `mean(x)`, `max(x)`, `min(x)` | Full reduction over all entries to a scalar. |
@@ -195,6 +194,10 @@ Enter comma-separated assignments in the **Input Values** box:
 * **Vectors**: `v = [1.0, -2.0, 3.0], b = 0.5`
 * **Matrices**: `W = [[1.0, 2.0], [3.0, 4.0]], x = [0.5, -1.0]`
 
+### Undefined and infinite values
+
+Both engines follow IEEE/PyTorch conventions. Infinite limits are shown as $\infty$: for example $\log 0 = -\infty$, the derivative of $\sqrt{x}$ at $0$ is $+\infty$, and $1/0 = \infty$. Values that are undefined, such as $\log(-1)$, $\sqrt{-4}$, $0/0$ or $\infty - \infty$, stop the computation with an error message naming the affected quantity.
+
 > **Scalar Output Requirement**: The overall formula must evaluate to a single scalar (e.g. via `sum(...)`, `mean(...)`, `dot(...)`, indexing `v[0]`, or scalar operations), because reverse-mode autodiff propagates sensitivities from a scalar root.
 
 ---

frontend/src/graph_widget.ts

@@ -77,6 +77,8 @@ export class InteractiveGraphWidget {
   private stepsByUid: Map<string, StepData> = new Map();
   private stepsBySourceUid: Map<string, StepData[]> = new Map();
 
+  private pendingFocusKey: string | null = null;
+
   constructor(rootEl: HTMLElement, payload: GraphPayload) {
     this.rootEl = rootEl;
     this.payload = payload;
@@ -156,6 +158,7 @@ export class InteractiveGraphWidget {
     const htmlLayer = document.createElement('div');
     htmlLayer.className = 'dvi-html-layer';
     this.htmlLayerEl = htmlLayer;
+    this.installKeyboardSupport();
     viewport.appendChild(htmlLayer);
 
     const inspector = document.createElement('div');
@@ -297,6 +300,23 @@ export class InteractiveGraphWidget {
     const nodes: LayoutNodeInfo[] = [];
     const edges: LayoutEdgeInfo[] = [];
 
+    this.buildQuantityNodes(math, nodes);
+    this.buildOutputNode(nodes);
+    const shownStepUids = new Set<string>();
+    this.buildStepAndSigmaNodes(math, nodes, shownStepUids);
+    this.buildEdges(math, nodes, edges, shownStepUids);
+    this.layoutAndDraw(nodes, edges);
+
+    this.applyFocusHighlighting();
+    this.applyAccessibility();
+
+    if (autoFit) {
+      requestAnimationFrame(() => this.fitToViewport(false));
+    }
+  }
+
+  /** Phase 1: DOM elements for quantity (and constant) nodes. */
+  private buildQuantityNodes(math: ReturnType<InteractiveGraphWidget["getMathRenderer"]>, nodes: LayoutNodeInfo[]): void {
     // 1. Create DOM elements for Quantities
     for (const q of this.payload.quantities) {
       const el = document.createElement('div');
@@ -329,12 +349,12 @@ export class InteractiveGraphWidget {
       if (this.editingNodeUid === q.uid) {
         primalHtml = `
           <div class="dvi-q-primal">
-            <input type="text" class="dvi-rename-input" value="${escapeHtml(qName)}" data-rename-uid="${q.uid}" />
+            <input type="text" class="dvi-rename-input" value="${escapeHtml(qName)}" data-rename-uid="${escapeHtml(q.uid)}" />
           </div>
         `;
       } else if (this.graphMode === 'compact') {
         // In compact mode, show only the node name (no rename function; hover/click opens tensor inspector)
-        const hoverAttrs = `data-inspect-node="${q.uid}"`;
+        const hoverAttrs = `data-inspect-node="${escapeHtml(q.uid)}"`;
         primalHtml = `
           <div class="dvi-q-primal dvi-tensor-trigger" ${hoverAttrs} title="${
           q.operation ? 'Click to highlight paths' : 'Input node'
@@ -343,7 +363,7 @@ export class InteractiveGraphWidget {
           </div>
         `;
       } else {
-        const hoverAttrs = `data-inspect-node="${q.uid}"`;
+        const hoverAttrs = `data-inspect-node="${escapeHtml(q.uid)}"`;
         const valHtml = math.renderValueHtml(q.primal, hoverAttrs);
         let lhsAndFormulaTex = qNameTex;
         if (q.operation) {
@@ -354,7 +374,7 @@ export class InteractiveGraphWidget {
           <div class="dvi-q-primal">
             <span>${renderKatex(`${lhsAndFormulaTex} =`, false)}</span>
             ${valHtml}
-            <button type="button" class="dvi-rename-btn" data-trigger-rename="${q.uid}" title="Rename variable (${escapeHtml(qName)})">✎</button>
+            <button type="button" class="dvi-rename-btn" data-trigger-rename="${escapeHtml(q.uid)}" title="Rename variable (${escapeHtml(qName)})">✎</button>
           </div>
         `;
       }
@@ -372,14 +392,14 @@ export class InteractiveGraphWidget {
           this.payload.notation === 'mathbook'
             ? `\\overline{${qNameTex}} =`
             : `${qNameTex}_{\\mathrm{bar}} =`;
-        const hoverAttrs = `data-inspect-node="${q.uid}"`;
+        const hoverAttrs = `data-inspect-node="${escapeHtml(q.uid)}"`;
         const adjValHtml = math.renderValueHtml(q.adjoint, hoverAttrs);
 
         const outSteps = this.stepsBySourceUid.get(q.uid) || [];
 
         adjointHtml = `
           <div class="dvi-q-divider"></div>
-          <div class="dvi-q-adjoint" data-toggle-source-steps="${q.uid}" title="${
+          <div class="dvi-q-adjoint" data-toggle-source-steps="${escapeHtml(q.uid)}" title="${
           outSteps.length > 0 ? 'Click to toggle backward step details' : ''
         }">
             <span>${renderKatex(adjTex, false)}</span>
@@ -402,7 +422,10 @@ export class InteractiveGraphWidget {
         quantity: q,
       });
     }
+  }
 
+  /** Phase 2: the empty output boundary circle. */
+  private buildOutputNode(nodes: LayoutNodeInfo[]): void {
     // 2. Output Boundary Node
     if (this.payload.outputStateUid) {
       const outEl = document.createElement('div');
@@ -419,9 +442,11 @@ export class InteractiveGraphWidget {
         region: 'output',
       });
     }
+  }
 
+  /** Phase 3: backward step trapezoids and Σ accumulation nodes. */
+  private buildStepAndSigmaNodes(math: ReturnType<InteractiveGraphWidget["getMathRenderer"]>, nodes: LayoutNodeInfo[], shownStepUids: Set<string>): void {
     // 3. Backward Step Nodes & Sigma Accumulations
-    const shownStepUids = new Set<string>();
     if (!this.payload.forwardOnly) {
       for (const step of this.payload.steps) {
         if (!this.isStepShownAsNode(step.uid)) continue;
@@ -534,7 +559,10 @@ export class InteractiveGraphWidget {
         });
       }
     }
+  }
 
+  /** Phase 4: forward/backward edges and their labels. */
+  private buildEdges(math: ReturnType<InteractiveGraphWidget["getMathRenderer"]>, nodes: LayoutNodeInfo[], edges: LayoutEdgeInfo[], shownStepUids: Set<string>): void {
     // 4. Build Edges & Edge Labels
     // Forward Edges
     this.payload.forwardEdges.forEach((fe, idx) => {
@@ -785,7 +813,10 @@ export class InteractiveGraphWidget {
       this.htmlLayerEl.appendChild(lbl);
       edge.labelEl = lbl;
     }
+  }
 
+  /** Phases 5-9: measure, run the Dagre layout, draw bands, position nodes and curved edges. */
+  private layoutAndDraw(nodes: LayoutNodeInfo[], edges: LayoutEdgeInfo[]): void {
     // 5. Measure actual DOM dimensions before running Dagre layout
     const prevTransform = this.htmlLayerEl.style.transform;
     this.htmlLayerEl.style.transform = 'translate(0px, 0px) scale(1)';
@@ -964,12 +995,74 @@ export class InteractiveGraphWidget {
         item.edge.labelEl.style.top = `${item.y}px`;
       }
     }
+  }
 
-    this.applyFocusHighlighting();
+  /**
+   * Keyboard and screen-reader support. Interactive targets become focusable
+   * buttons: Enter/Space activates (click), focus shows the inspector (hover),
+   * F2 renames a quantity. Because every render rebuilds the DOM, focus is
+   * restored to the element with the same stable key afterwards.
+   */
+  private static readonly A11Y_TARGETS: Array<[string, (el: HTMLElement) => string]> = [
+    ['.dvi-node-quantity', () => 'Quantity: activate to highlight connections, F2 to rename'],
+    ['.dvi-node-step', () => 'Backward step: activate to toggle its derivation'],
+    ['.dvi-node-sigma', () => 'Sum of gradient contributions'],
+    ['.dvi-q-adjoint[data-toggle-source-steps]', () => 'Adjoint: activate to toggle outgoing backward steps'],
+    ['.dvi-tensor-trigger', () => 'Inspect tensor values'],
+    ['.dvi-edge-label-expandable, .dvi-edge-label[style*="cursor"]', () => 'Edge value: activate to expand or inspect'],
+  ];
+
+  private a11yKey(el: HTMLElement): string | null {
+    const host = el.closest<HTMLElement>('[data-node-id], [data-edge-id]');
+    if (!host) return null;
+    const id = host.getAttribute('data-node-id') ?? `edge:${host.getAttribute('data-edge-id')}`;
+    return el === host ? id : `${id}|${el.className}`;
+  }
 
-    if (autoFit) {
-      requestAnimationFrame(() => this.fitToViewport(false));
+  private applyAccessibility(): void {
+    const layer = this.htmlLayerEl;
+    for (const [selector, label] of InteractiveGraphWidget.A11Y_TARGETS) {
+      layer.querySelectorAll<HTMLElement>(selector).forEach((el) => {
+        el.tabIndex = 0;
+        el.setAttribute('role', 'button');
+        const q = this.quantitiesByUid.get(el.getAttribute('data-node-id') || '');
+        const prefix = q && el.classList.contains('dvi-node-quantity') ? `${this.getDisplayName(q)}. ` : '';
+        el.setAttribute('aria-label', prefix + label(el));
+      });
     }
+    layer.querySelectorAll<HTMLElement>('[data-trigger-rename]').forEach((btn) => {
+      btn.setAttribute('aria-label', btn.title || 'Rename variable');
+    });
+    if (this.pendingFocusKey) {
+      const key = this.pendingFocusKey;
+      this.pendingFocusKey = null;
+      const target = Array.from(layer.querySelectorAll<HTMLElement>('[tabindex="0"]'))
+        .find((el) => this.a11yKey(el) === key);
+      target?.focus({ preventScroll: true });
+    }
+  }
+
+  private installKeyboardSupport(): void {
+    const layer = this.htmlLayerEl;
+    const isTarget = (t: EventTarget | null): t is HTMLElement =>
+      t instanceof HTMLElement && t.getAttribute('role') === 'button' && layer.contains(t);
+    layer.addEventListener('keydown', (ev) => {
+      if (!isTarget(ev.target)) return;
+      if (ev.key === 'Enter' || ev.key === ' ') {
+        ev.preventDefault();
+        this.pendingFocusKey = this.a11yKey(ev.target);
+        ev.target.click();
+      } else if (ev.key === 'F2' && ev.target.classList.contains('dvi-node-quantity')) {
+        ev.preventDefault();
+        ev.target.dispatchEvent(new MouseEvent('dblclick', { bubbles: true }));
+      }
+    });
+    layer.addEventListener('focusin', (ev) => {
+      if (isTarget(ev.target)) ev.target.dispatchEvent(new MouseEvent('mouseenter'));
+    });
+    layer.addEventListener('focusout', (ev) => {
+      if (isTarget(ev.target)) ev.target.dispatchEvent(new MouseEvent('mouseleave'));
+    });
   }
 
   /**

frontend/src/index.ts

@@ -1,8 +1,13 @@
+import katex from 'katex';
 import { GraphPayload } from './types';
 import { InteractiveGraphWidget } from './graph_widget';
 import { INTERACTIVE_GRAPH_CSS } from './styles';
 
-const KATEX_CSS_URL = 'https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/katex.min.css';
+// Stylesheet version always matches the bundled KaTeX JavaScript.
+const KATEX_CSS_URL = `https://cdn.jsdelivr.net/npm/katex@${katex.version}/dist/katex.min.css`;
+
+// Payload each container was last mounted with; a changed payload remounts.
+const mountedPayloads = new WeakMap<HTMLElement, string>();
 
 function ensureStylesInjected(): void {
   if (!document.getElementById('dvi-katex-css')) {
@@ -25,19 +30,21 @@ function ensureStylesInjected(): void {
 
 function mountAllInteractiveGraphs(): void {
   ensureStylesInjected();
-  const containers = document.querySelectorAll<HTMLElement>(
-    '.dv-interactive-root[data-graph]:not([data-dvi-mounted="true"])'
-  );
+  const containers = document.querySelectorAll<HTMLElement>('.dv-interactive-root[data-graph]');
   containers.forEach((el) => {
     const raw = el.getAttribute('data-graph');
-    if (!raw) return;
+    if (!raw || mountedPayloads.get(el) === raw) return;
+    mountedPayloads.set(el, raw);
     el.setAttribute('data-dvi-mounted', 'true');
     try {
       const payload = JSON.parse(raw) as GraphPayload;
       new InteractiveGraphWidget(el, payload);
     } catch (err) {
       console.error('Failed to mount InteractiveGraphWidget:', err);
-      el.innerHTML = `<div style="color:#b91c1c;padding:16px;">Failed to initialize interactive graph: ${String(err)}</div>`;
+      const message = document.createElement('div');
+      message.style.cssText = 'color:#b91c1c;padding:16px;';
+      message.textContent = `Failed to initialize interactive graph: ${String(err)}`;
+      el.replaceChildren(message);
     }
   });
 }

frontend/src/math_view.ts

@@ -53,6 +53,9 @@ export function formatLatexNum(
   cfg: FormatConfig = { precision: 2, allowScientific: true }
 ): string {
   const s = formatNum(value, cfg);
+  if (s === 'inf' || s === 'Infinity') return '\\infty';
+  if (s === '-inf' || s === '-Infinity') return '-\\infty';
+  if (s === 'nan' || s === 'NaN') return '\\mathrm{NaN}';
   if (s.includes('e')) {
     const [m, e] = s.split('e');
     return `${m}\\times 10^{${parseInt(e, 10)}}`;
@@ -186,7 +189,9 @@ export function renderKatex(tex: string, displayMode = false): string {
       throwOnError: false,
       displayMode,
       strict: false,
-      trust: true,
+      // Never trust: \href, \url, \html* and \includegraphics stay disabled.
+      trust: false,
+      maxExpand: 1000,
     });
   } catch {
     return `<code>${escapeHtml(tex)}</code>`;

frontend/src/types.ts

@@ -4,7 +4,6 @@ export interface SerializedValue {
   data: any;
   min?: number;
   max?: number;
-  norm?: number;
 }
 
 export interface ExprData {
@@ -35,7 +34,6 @@ export interface ExplanationData {
 
 export interface OperationData {
   kind: string;
-  function: string | null;
   operands: string[];
   formula: ExprData;
   stopExplanation: ExplanationData | null;
@@ -61,7 +59,6 @@ export interface StepData {
   incomingAdjoint: SerializedValue;
   localValue: SerializedValue;
   contribution: SerializedValue;
-  isScalarRule: boolean;
   explanation: ExplanationData | null;
 }
 
@@ -76,7 +73,6 @@ export interface ForwardEdgeData {
   source: string;
   destination: string;
   value: SerializedValue;
-  operandOccurrence: number | null;
 }
 
 export interface BackwardEdgeData {
@@ -99,7 +95,6 @@ export interface GraphPayload {
   outputName: string;
   formula: string;
   forwardOnly: boolean;
-  rootUid: string;
   outputStateUid: string | null;
   notation: 'mathbook' | 'code';
   formatConfig: FormatConfig;

input_parser.py

@@ -2,10 +2,9 @@ import ast
 import re
 import numpy as np
 
-MAX_INPUT_TEXT_LEN = 1000
-MAX_TOTAL_ELEMENTS = 50000
-MAX_ARRAY_RANK = 2
-MAX_NUMERIC_MAGNITUDE = 1e9
+from limits import (
+    MAX_ARRAY_RANK, MAX_INPUT_TEXT_LEN, MAX_NUMERIC_MAGNITUDE, MAX_TOTAL_ELEMENTS, VARIABLE_NAME_PATTERN,
+)
 
 def split_top_level_assignments(text):
     """
@@ -55,12 +54,6 @@ def _validate_and_convert_literal(node):
             raise ValueError(f"Numeric literal exceeds maximum allowed magnitude ({MAX_NUMERIC_MAGNITUDE}).")
         return val
 
-    if hasattr(ast, "Num") and isinstance(node, ast.Num):
-        val = float(node.n)
-        if abs(val) > MAX_NUMERIC_MAGNITUDE:
-            raise ValueError(f"Numeric literal exceeds maximum allowed magnitude.")
-        return val
-
     if isinstance(node, ast.UnaryOp):
         if isinstance(node.op, ast.UAdd):
             return +_validate_and_convert_literal(node.operand)
@@ -143,7 +136,7 @@ def parse_variable_assignments(text):
         var_name = var_part.strip()
         val_str = val_part.strip()
 
-        if not re.match(r"^[a-zA-Z][a-zA-Z0-9_]*$", var_name):
+        if not re.match(VARIABLE_NAME_PATTERN, var_name):
             raise ValueError(f"Invalid variable identifier: '{var_name}'")
 
         if var_name in feed_dict:

interactive_renderer.py

@@ -8,6 +8,8 @@ backward derivations on demand.
 """
 from __future__ import annotations
 
+import math
+
 import html
 import json
 from typing import Any
@@ -41,14 +43,12 @@ def _serialize_array(val: Any) -> dict[str, Any]:
     flat_finite = arr[np.isfinite(arr)]
     min_val = float(np.min(flat_finite)) if flat_finite.size > 0 else 0.0
     max_val = float(np.max(flat_finite)) if flat_finite.size > 0 else 0.0
-    norm_val = float(np.linalg.norm(flat_finite)) if flat_finite.size > 0 else 0.0
     return {
         "kind": "tensor",
         "shape": list(arr.shape),
         "data": arr.tolist(),
         "min": min_val,
         "max": max_val,
-        "norm": norm_val,
     }
 
 
@@ -97,7 +97,6 @@ def serialize_computation_model(
         if op is not None:
             q_dict["operation"] = {
                 "kind": op.kind,
-                "function": op.function,
                 "operands": [operand.uid for operand in op.operands],
                 "formula": op.formula.to_data(),
                 "stopExplanation": (
@@ -125,7 +124,6 @@ def serialize_computation_model(
             "incomingAdjoint": _serialize_array(step.incoming_adjoint),
             "localValue": _serialize_array(step.local_value),
             "contribution": _serialize_array(step.contribution),
-            "isScalarRule": step.rule.__class__.__name__ == "ScalarLocalRule",
             "explanation": {
                 "contribution": expl.contribution.to_data(),
                 "bindings": [_serialize_equation(b) for b in expl.bindings],
@@ -157,7 +155,6 @@ def serialize_computation_model(
             "source": edge.source,
             "destination": edge.destination,
             "value": _serialize_array(edge.value),
-            "operandOccurrence": edge.operand_occurrence,
         })
 
     backward_edges_data = []
@@ -182,7 +179,6 @@ def serialize_computation_model(
         "outputName": model.output_name,
         "formula": model.formula,
         "forwardOnly": model.forward_only,
-        "rootUid": model.root.uid,
         "outputStateUid": model.output.uid if model.output is not None else None,
         "notation": notation,
         "formatConfig": {
@@ -197,6 +193,16 @@ def serialize_computation_model(
     }
 
 
+def _json_safe(value):
+    if isinstance(value, float) and not math.isfinite(value):
+        return str(value)  # "inf", "-inf" or "nan"
+    if isinstance(value, dict):
+        return {k: _json_safe(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(v) for v in value]
+    return value
+
+
 def render_interactive_html(
     model: ComputationModel,
     notation: str = "mathbook",
@@ -204,5 +210,7 @@ def render_interactive_html(
 ) -> str:
     """Return the HTML container carrying the serialized ComputationModel JSON."""
     payload = serialize_computation_model(model, notation=notation, format_config=format_config)
-    json_attr = html.escape(json.dumps(payload, separators=(",", ":")), quote=True)
+    # JSON has no Infinity/NaN literals (JSON.parse rejects them): encode as strings.
+    json_text = json.dumps(_json_safe(payload), separators=(",", ":"), allow_nan=False)
+    json_attr = html.escape(json_text, quote=True)
     return f'<div class="dv-interactive-root" data-graph="{json_attr}"></div>'

limits.py

@@ -0,0 +1,51 @@
+"""Input limits and the bounded AST validator shared by both engines and the value parser."""
+import ast
+
+MAX_EXPR_LEN = 200
+MAX_AST_NODES = 250
+MAX_AST_DEPTH = 35
+MAX_NUMERIC_MAGNITUDE = 1e9
+MAX_EXPONENT_MAGNITUDE = 50
+
+MAX_INPUT_TEXT_LEN = 1000
+MAX_TOTAL_ELEMENTS = 50000
+MAX_ARRAY_RANK = 2
+
+VARIABLE_NAME_PATTERN = r"^[a-zA-Z][a-zA-Z0-9_]*$"
+
+SCALAR_AST_TYPES = (
+    ast.Expression, ast.BinOp, ast.UnaryOp,
+    ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Pow, ast.UAdd, ast.USub,
+    ast.Name, ast.Constant, ast.Call, ast.Load,
+)
+
+
+class BoundedASTValidator(ast.NodeVisitor):
+    """Reject disallowed syntax and bound expression size and nesting depth."""
+
+    allowed_types = SCALAR_AST_TYPES
+
+    def __init__(self):
+        self.node_count = 0
+        self.current_depth = 0
+
+    def visit(self, node):
+        self.node_count += 1
+        if self.node_count > MAX_AST_NODES:
+            raise ValueError(f"Expression exceeds complexity limit ({MAX_AST_NODES} nodes).")
+        self.current_depth += 1
+        if self.current_depth > MAX_AST_DEPTH:
+            raise ValueError(f"Expression nesting too deep (max depth {MAX_AST_DEPTH}).")
+        result = super().visit(node)
+        self.current_depth -= 1
+        return result
+
+    def generic_visit(self, node):
+        if not isinstance(node, self.allowed_types):
+            raise ValueError(f"Disallowed construct: {type(node).__name__}")
+        super().generic_visit(node)
+
+    def visit_Call(self, node):
+        if node.keywords:
+            raise ValueError("Keyword arguments are not allowed in function calls.")
+        self.generic_visit(node)

math_expression.py

@@ -85,7 +85,7 @@ class Expr:
             'relu': lambda a: np.maximum(a, 0),
             'softmax': lambda a: np.exp(a - np.max(a)) / np.sum(np.exp(a - np.max(a))),
             'nograd': lambda a: a,
-            'sin': np.sin, 'cos': np.cos, 'tan': np.tan,
+            'sin': np.sin, 'cos': np.cos, 'tan': np.tan, 'sqrt': np.sqrt,
             'asin': np.arcsin, 'acos': np.arccos, 'atan': np.arctan,
             'sinh': np.sinh, 'cosh': np.cosh, 'tanh': np.tanh,
             'exp': np.exp, 'log': np.log, 'Abs': np.abs, 'sign': np.sign,

requirements-dev.txt

@@ -0,0 +1,2 @@
+-r requirements.txt
+pytest

tensor_engine.py

@@ -2,6 +2,13 @@ import ast
 import re
 import numpy as np
 from number_format import format_num as _scalar_format_num
+from limits import (
+    BoundedASTValidator, SCALAR_AST_TYPES, MAX_AST_DEPTH, MAX_AST_NODES, MAX_ARRAY_RANK, MAX_TOTAL_ELEMENTS, MAX_EXPR_LEN,
+    MAX_NUMERIC_MAGNITUDE, MAX_EXPONENT_MAGNITUDE, VARIABLE_NAME_PATTERN,
+)
+
+MAX_PREVIEW_ELEMENTS = 4
+
 
 
 def format_num(val, sig_figs=4, config=None, precision=None, allow_scientific=None):
@@ -10,16 +17,6 @@ def format_num(val, sig_figs=4, config=None, precision=None, allow_scientific=No
     return _scalar_format_num(val, sig_figs=sig_figs, config=config, precision=precision, allow_scientific=allow_scientific)
 
 
-MAX_ARRAY_RANK = 2
-MAX_TOTAL_ELEMENTS = 50000
-MAX_PREVIEW_ELEMENTS = 4
-
-MAX_EXPR_LEN = 200
-MAX_AST_NODES = 250
-MAX_AST_DEPTH = 35
-MAX_NUMERIC_MAGNITUDE = 1e9
-MAX_EXPONENT_MAGNITUDE = 50
-
 TENSOR_ALLOWED_FUNCS = {
     "sigmoid",
     "relu",
@@ -34,61 +31,38 @@ TENSOR_ALLOWED_FUNCS = {
     "softmax",
     "pick",
     "nograd",
+    # Elementwise functions shared with the scalar engine.
+    "sin",
+    "cos",
+    "tan",
+    "sqrt",
+    "sinh",
+    "cosh",
+    "asin",
+    "acos",
+    "atan",
+    "abs",
+    "Abs",
+    "ln",
 }
 
+# Aliases normalised to one canonical function name (as in the scalar engine).
+TENSOR_FUNC_ALIASES = {"abs": "Abs", "ln": "log"}
 
-class TensorASTValidator(ast.NodeVisitor):
-    def __init__(self):
-        self.node_count = 0
-        self.max_depth = 0
-        self.current_depth = 0
-
-    def visit(self, node):
-        self.node_count += 1
-        if self.node_count > MAX_AST_NODES:
-            raise ValueError(f"Expression exceeds complexity limit ({MAX_AST_NODES} nodes).")
-
-        self.current_depth += 1
-        if self.current_depth > self.max_depth:
-            self.max_depth = self.current_depth
-        if self.max_depth > MAX_AST_DEPTH:
-            raise ValueError(f"Expression nesting too deep (max depth {MAX_AST_DEPTH}).")
-
-        res = super().visit(node)
-        self.current_depth -= 1
-        return res
-
-    def generic_visit(self, node):
-        allowed_types = (
-            ast.Expression,
-            ast.BinOp,
-            ast.UnaryOp,
-            ast.Add,
-            ast.Sub,
-            ast.Mult,
-            ast.Div,
-            ast.Pow,
-            ast.MatMult,
-            ast.UAdd,
-            ast.USub,
-            ast.Name,
-            ast.Constant,
-            ast.Call,
-            ast.Load,
-            ast.List,
-            ast.Subscript,
-        )
-        if hasattr(ast, "Num"):
-            allowed_types = allowed_types + (ast.Num,)
+ELEMENTWISE_NUMPY = {
+    "tanh": np.tanh, "exp": np.exp, "log": np.log,
+    "sin": np.sin, "cos": np.cos, "tan": np.tan, "sqrt": np.sqrt,
+    "sinh": np.sinh, "cosh": np.cosh,
+    "asin": np.arcsin, "acos": np.arccos, "atan": np.arctan,
+    "Abs": np.abs,
+}
 
-        if not isinstance(node, allowed_types):
-            raise ValueError(f"Disallowed construct: {type(node).__name__}")
-        super().generic_visit(node)
 
-    def visit_Call(self, node):
-        if node.keywords:
-            raise ValueError("Keyword arguments are not allowed in function calls.")
-        self.generic_visit(node)
+class TensorASTValidator(BoundedASTValidator):
+    """Tensor grammar: the scalar grammar plus @, list literals and indexing."""
+
+    allowed_types = SCALAR_AST_TYPES + (ast.MatMult, ast.List, ast.Subscript)
+
 
 from tensor_formatter import format_tensor_value, format_tensor_shape, DEFAULT_TENSOR_ELEMENT_BUDGET
 
@@ -107,6 +81,30 @@ def format_tensor_badge(val, sig_figs=4, config=None):
     # Edge labels show value without trailing shape metadata to stay compact
     return format_tensor_value(val, element_budget=DEFAULT_TENSOR_ELEMENT_BUDGET, include_shape_if_truncated=False, config=config)
 
+_OP_SYMBOLS = {"neg": "negation", "add": "+", "sub": "-", "mul": "*", "div": "/",
+               "pow": "**", "matmul": "@", "dot": "dot"}
+
+
+def _op_label(node):
+    return node.func_name if node.op_type == "func" else _OP_SYMBOLS.get(node.op_type, node.op_type)
+
+
+def _require_defined(value, description):
+    """Shared numeric policy with the scalar engine (IEEE/PyTorch convention).
+
+    Infinite values (e.g. log(0) = -inf, d/dx sqrt(x) at 0 = +inf) are
+    legitimate limits and are shown. NaN means the quantity is undefined
+    (e.g. log(-1), sqrt(-1), inf - inf) and is reported instead of displayed.
+    """
+    arr = np.asarray(value, dtype=np.float64)
+    nan_mask = np.isnan(arr)
+    if not nan_mask.any():
+        return
+    where = "" if arr.ndim == 0 else f" in {int(nan_mask.sum())} of {arr.size} entries"
+    raise ValueError(
+        f"{description} is undefined{where} (e.g. log or a fractional power of a negative "
+        "number, 0/0, or inf - inf)."
+    )
 
 
 class TensorNode:
@@ -191,8 +189,6 @@ class TensorComputationGraph:
             if isinstance(node.value, bool) or not isinstance(node.value, (int, float)):
                 return None
             return float(node.value)
-        if hasattr(ast, "Num") and isinstance(node, ast.Num):
-            return float(node.n)
         if isinstance(node, ast.UnaryOp):
             val = self._extract_constant_scalar(node.operand)
             if val is None:
@@ -242,22 +238,6 @@ class TensorComputationGraph:
             self.nodes.append(c_node)
             return c_node
 
-        if hasattr(ast, "Num") and isinstance(node, ast.Num):
-            val = float(node.n)
-            if abs(val) > MAX_NUMERIC_MAGNITUDE:
-                raise ValueError(f"Numeric constant {val} exceeds maximum allowed magnitude.")
-            self.cst_counter += 1
-            c_node = TensorNode(
-                uid=f"cst_{self.cst_counter}_{str(val).replace('-', 'neg_').replace('.', '_')}",
-                name=format_num(val),
-                op_type="const",
-                is_input=True,
-                is_constant=True,
-                const_val=val,
-            )
-            self.nodes.append(c_node)
-            return c_node
-
         if isinstance(node, ast.List):
             from input_parser import _validate_and_convert_literal
             arr_val = np.array(_validate_and_convert_literal(node), dtype=np.float64)
@@ -275,7 +255,7 @@ class TensorComputationGraph:
 
         if isinstance(node, ast.Name):
             var_name = node.id
-            if not re.match(r"^[a-zA-Z][a-zA-Z0-9_]*$", var_name):
+            if not re.match(VARIABLE_NAME_PATTERN, var_name):
                 raise ValueError(f"Invalid variable identifier: {var_name}")
             if var_name in self.name_to_input:
                 return self.name_to_input[var_name]
@@ -315,7 +295,8 @@ class TensorComputationGraph:
                 # Check for signed numeric constant exponent
                 exp_val = self._extract_constant_scalar(node.right)
                 if exp_val is None:
-                    raise ValueError("Tensor power currently requires a finite scalar constant exponent.")
+                    raise ValueError("Vector/matrix expressions require a constant exponent (e.g. v**2). "
+                                     "Variable exponents such as x**y are only supported when every input is a scalar.")
                 if abs(exp_val) > MAX_EXPONENT_MAGNITUDE:
                     raise ValueError(f"Exponent magnitude {exp_val} exceeds limit of {MAX_EXPONENT_MAGNITUDE}.")
 
@@ -411,7 +392,7 @@ class TensorComputationGraph:
                     op_type="func",
                     is_input=False,
                 )
-                op_node.func_name = func_name
+                op_node.func_name = TENSOR_FUNC_ALIASES.get(func_name, func_name)
                 op_node.args = [child_node]
                 self.nodes.append(op_node)
                 return op_node
@@ -442,6 +423,7 @@ class TensorComputationGraph:
             else:
                 # Evaluate intermediate operation
                 self._evaluate_forward_op(node)
+                _require_defined(node.val, f"Value of {node.name} ({_op_label(node)})")
 
         # Enforce scalar root restriction in both modes
         if self.root.shape != ():
@@ -601,18 +583,8 @@ class TensorComputationGraph:
                 if isinstance(node.val, np.ndarray) and node.val.ndim == 0:
                     node.val = np.float64(node.val)
                 node.shape = child.shape
-            elif f == "tanh":
-                node.val = np.tanh(child.val)
-                if isinstance(node.val, np.ndarray) and node.val.ndim == 0:
-                    node.val = np.float64(node.val)
-                node.shape = child.shape
-            elif f == "exp":
-                node.val = np.exp(child.val)
-                if isinstance(node.val, np.ndarray) and node.val.ndim == 0:
-                    node.val = np.float64(node.val)
-                node.shape = child.shape
-            elif f == "log":
-                node.val = np.log(child.val)
+            elif f in ELEMENTWISE_NUMPY:
+                node.val = ELEMENTWISE_NUMPY[f](child.val)
                 if isinstance(node.val, np.ndarray) and node.val.ndim == 0:
                     node.val = np.float64(node.val)
                 node.shape = child.shape
@@ -654,6 +626,7 @@ class TensorComputationGraph:
             contribution = rule.application.evaluate(values)
             if child.shape == ():
                 contribution = float(contribution)
+            _require_defined(contribution, f"Gradient contribution from {node.name} ({_op_label(node)}) to {child.name}")
             record = {'arg_node': child, 'operand_occurrence': occurrence,
                       'rule': rule, 'contrib_val': contribution}
             if isinstance(rule, ScalarLocalRule):

tests/test_numeric_policy.py

@@ -0,0 +1,110 @@
+"""Regression tests: abs, edge-point derivatives, shared numeric policy, engine dispatch."""
+import numpy as np
+import pytest
+
+from app import build_model_from_inputs, generate_interactive_diagram, generate_trace, uses_tensor_engine
+from tensor_engine import TensorComputationGraph
+
+MODE = "Forward & Backward"
+
+
+def adjoint_of(model, name):
+    return next(q.adjoint_value for q in model.quantities if q.name == name)
+
+
+@pytest.mark.parametrize("value, expected", [(-2.0, 4.0), (0.0, 0.0), (3.0, 6.0)])
+def test_abs_is_differentiable_in_scalar_engine(value, expected):
+    model = build_model_from_inputs("abs(x) * x", f"x={value}", MODE)
+    assert adjoint_of(model, "x") == pytest.approx(expected)
+
+
+def test_fractional_power_at_zero_has_infinite_not_zero_derivative():
+    model = build_model_from_inputs("x**0.5", "x=0", MODE)
+    assert np.isposinf(adjoint_of(model, "x"))
+
+
+def test_zero_power_at_zero_has_zero_derivative():
+    model = build_model_from_inputs("x**0 + x", "x=0", MODE)
+    assert adjoint_of(model, "x") == pytest.approx(1.0)
+
+
+@pytest.mark.parametrize("expr, values", [
+    ("x**0.5", "x=-4"),
+    ("log(x)", "x=-1"),
+    ("x/y", "x=0, y=0"),
+    ("(-2)**x", "x=2"),
+    ("sum(x**0.5)", "x=[-1, 4]"),
+    ("sum(log(x))", "x=[-1, 1]"),
+])
+def test_undefined_values_raise_readable_errors_in_both_engines(expr, values):
+    with pytest.raises(ValueError, match="undefined|not a real number"):
+        build_model_from_inputs(expr, values, MODE)
+
+
+@pytest.mark.parametrize("scalar_expr, tensor_expr, values", [
+    ("log(x)", "sum(log(x))", ("x=0", "x=[0]")),
+    ("x**0.5", "sum(x**0.5)", ("x=0", "x=[0]")),
+    ("1/x", "sum(1/x)", ("x=0", "x=[0]")),
+])
+def test_engines_agree_on_infinite_limits(scalar_expr, tensor_expr, values):
+    scalar = build_model_from_inputs(scalar_expr, values[0], MODE)
+    tensor = build_model_from_inputs(tensor_expr, values[1], MODE)
+    np.testing.assert_array_equal(np.ravel(adjoint_of(scalar, "x")), np.ravel(adjoint_of(tensor, "x")))
+
+
+def test_scalar_overflow_is_reported_as_infinity_not_crash():
+    model = build_model_from_inputs("exp(exp(exp(x)))", "x=5", MODE)
+    assert np.isposinf(adjoint_of(model, "x"))
+
+
+@pytest.mark.parametrize("func, point", [
+    ("sin", [0.3, -0.4]), ("cos", [0.3, -0.4]), ("tan", [0.3, -0.4]),
+    ("sqrt", [0.3, 0.7]), ("sinh", [0.3, -0.4]), ("cosh", [0.3, -0.4]),
+    ("asin", [0.3, -0.4]), ("acos", [0.3, -0.4]), ("atan", [0.3, -0.4]),
+    ("abs", [0.3, -0.4]), ("ln", [0.3, 0.7]),
+])
+def test_tensor_elementwise_functions_match_finite_differences(func, point):
+    expr = f"sum({func}(x))"
+    x = np.array(point)
+    graph = TensorComputationGraph().build_from_ast(expr)
+    graph.evaluate({"x": x})
+    numeric = np.zeros_like(x)
+    for i in range(x.size):
+        step = np.zeros_like(x)
+        step[i] = 1e-6
+        plus = TensorComputationGraph().build_from_ast(expr)
+        plus.evaluate({"x": x + step}, forward_only=True)
+        minus = TensorComputationGraph().build_from_ast(expr)
+        minus.evaluate({"x": x - step}, forward_only=True)
+        numeric[i] = (plus.root.val - minus.root.val) / 2e-6
+    np.testing.assert_allclose(graph.name_to_input["x"].grad, numeric, atol=1e-5)
+    assert "Error" not in generate_trace(expr, f"x={point}", MODE)
+    assert "Error" not in generate_interactive_diagram(expr, f"x={point}", MODE)
+
+
+def test_mixed_scalar_function_and_tensor_reduction():
+    model = build_model_from_inputs("sin(x) + sum(v)", "x=1, v=[1, 2]", MODE)
+    assert adjoint_of(model, "x") == pytest.approx(np.cos(1.0))
+
+
+@pytest.mark.parametrize("expr, feed, expected", [
+    ("sin(x) * y", {"x": 1.0}, False),
+    ("maximum + x", {"x": 1.0}, False),  # a variable named like a function
+    ("sum(v)", {"v": 1.0}, True),
+    ("v[0]", {}, True),
+    ("x", {"x": np.array([1.0])}, True),
+])
+def test_engine_dispatch(expr, feed, expected):
+    assert uses_tensor_engine(expr, feed) is expected
+
+
+def test_variable_exponent_error_explains_scalar_only_support():
+    with pytest.raises(ValueError, match="only supported when every input is a scalar"):
+        build_model_from_inputs("sum(v**y)", "v=[1, 2], y=2", MODE)
+
+
+def test_boolean_constants_rejected_in_both_engines():
+    with pytest.raises(ValueError, match="Boolean"):
+        build_model_from_inputs("True * x", "x=1", MODE)
+    with pytest.raises(ValueError, match="Boolean"):
+        build_model_from_inputs("sum(True * v)", "v=[1]", MODE)

tests/test_url_loading.py

@@ -29,7 +29,7 @@ def test_load_from_request_direct():
 
     # 1. Test empty request
     res_empty = load_fn(None)
-    assert len(res_empty) == 11
+    assert len(res_empty) == 12
     assert all(isinstance(x, gr.components.Component) or x == gr.skip() for x in res_empty)
 
     # 2. Test formula and values
@@ -42,7 +42,7 @@ def test_load_from_request_direct():
         "sci": "false",
         "autorun": "true",
     })
-    tabs_up, expr_up, expl_up, vals_up, mode_up, not_up, prec_up, sci_up, diag_up, code_up, trace_up = load_fn(req)
+    tabs_up, expr_up, expl_up, vals_up, mode_up, not_up, prec_up, sci_up, diag_up, code_up, trace_up, inter_up = load_fn(req)
 
     assert expr_up == "x * y + 3"
     assert vals_up == "x=2, y=5"
@@ -58,6 +58,26 @@ def test_load_from_request_direct():
         "tab": "trace",
         "autorun": "1",
     })
-    tabs_up, expr_up, expl_up, vals_up, mode_up, not_up, prec_up, sci_up, diag_up, code_up, trace_up = load_fn(req_trace)
+    tabs_up, expr_up, expl_up, vals_up, mode_up, not_up, prec_up, sci_up, diag_up, code_up, trace_up, inter_up = load_fn(req_trace)
     assert getattr(tabs_up, "value", None) == "tab_trace" or getattr(tabs_up, "selected", None) == "tab_trace" or (isinstance(tabs_up, gr.Tabs) and tabs_up.selected == "tab_trace")
     assert "<" in trace_up or "sin" in trace_up
+
+
+def _load_fn():
+    return next(item.fn for item in demo.fns.values()
+                if hasattr(item, "fn") and item.fn.__name__ == "load_from_request")
+
+
+def test_load_defaults_to_interactive_tab_and_autoruns_it():
+    result = _load_fn()(DummyRequest({"expr": "x * y", "vals": "x=2, y=3"}))
+    assert result[0].selected == "tab_interactive"
+    assert result[-1] != gr.skip() and "Error" not in result[-1]
+
+
+def test_url_values_cannot_inject_html_into_error_messages():
+    result = _load_fn()(DummyRequest({
+        "expr": "x", "vals": "x=<img src=x onerror=alert(1)>", "tab": "diagram",
+    }))
+    diagram_html = result[8]
+    assert "<img src=x" not in diagram_html
+    assert "&lt;img src=x onerror=alert(1)&gt;" in diagram_html