step one

README.md

@@ -10,32 +10,88 @@ app_file: app.py
 pinned: false
 ---
 
-# Differ Hug: Interactive ODE Research Platform
+# Differ Hug: ODE Research Platform
 
-A computational framework for exploring and visualizing ordinary differential equations (ODEs) in real-time.
+An interactive platform for exploring and analyzing ordinary differential equations (ODEs), focused on gene regulatory systems and numerical diagnostics.
 
-## Research Capabilities
+## Features
 
-- **Phase Portrait Visualization**: Generate and analyze phase space trajectories for autonomous and non-autonomous systems
-- **Attractor Analysis**: Investigate chaotic attractors, limit cycles, and stable/unstable manifolds
-- **Vector Field Rendering**: Visualize flow fields and direction fields with customizable resolution
-- **Parameter Space Exploration**: Systematically vary system parameters to observe bifurcations and qualitative changes in dynamics
-- **Numerical Integration**: Multiple solver methods (RK4, LSODA) with adaptive step size control
+### ode System
+- **Gene Regulatory ODE System**: Cooperative sigmoidal activation model
+- **Numerical Integration**: High-precision DOP853 solver with RK45 fallback
+- **Initial Conditions**: Circular/sector-based ensembles with controllable center and radius
 
-## Technical Stack
+### Diagnostics & Metrics
+- **FTLE**: Finite-Time Lyapunov Exponent with R² reliability metric
+- **Hurst Exponent**: Rescaled range (R/S) analysis for time series
+- **Curvature Statistics**: Mean, median, std, p10, p90 of curvature radius
+- **Path Length**: Total arclength of trajectories
+- **Local Z-score**: Nearest-neighbor analysis of curvature metrics
+- **Anomaly Score**: Combined robust z-scores for outlying trajectories
 
-- **Gradio**: Interactive web interface for parameter adjustment and real-time visualization
-- **NumPy/SciPy**: High-performance numerical computation and ODE solvers
-- **Matplotlib**: Publication-quality phase portraits and time series plots
-- **Hugging Face Spaces**: Cloud-based deployment and reproducible research environment
+### Visualization
+- **Phase Portrait**: Trajectories in phase space with annotations
+- **Time Series**: x(t) and y(t) evolution over time
+- **Shadowing Analysis**: Perturbation growth visualization
+- **Metrics Table**: Full diagnostic output with highlighting
+
+## Requirements
+
+```
+gradio>=4.44.1
+numpy>=1.24.0
+scipy>=1.10.0
+matplotlib>=3.7.0
+pandas (optional for extended functionality)
+```
 
 ## Usage
 
-Access the interactive interface to:
-- Select from predefined ODE systems (Lorenz, Van der Pol, Lotka-Volterra, etc.)
-- Adjust initial conditions and system parameters through interactive controls
-- Generate phase portraits, time series, and 3D trajectory visualizations
-- Export results for further analysis
+Run the application locally:
+```bash
+python app.py
+```
+
+The app will be available at `http://localhost:7860`
+
+## ODE System
+
+The gene regulatory system:
+
+$$
+\begin{cases}
+\displaystyle \frac{dx}{dt} = \frac{K\,x^{1/\alpha}}{b^{1/\alpha} + x^{1/\alpha}} - \gamma_1\,x,\\[10pt]
+\displaystyle \frac{dy}{dt} = \frac{K\,y^{1/\alpha}}{b^{1/\alpha} + y^{1/\alpha}} - \gamma_2\,y.
+\end{cases}
+$$
+
+### Parameters
+- **alpha**: Controls sigmoid steepness (1/alpha = Hill coefficient)
+- **K**: Maximum activation rate
+- **b**: Half-activation constant
+- **gamma1, gamma2**: Decay rates
+
+## Project Structure
+
+```
+differ-hug/
+├── app.py                 # Gradio UI entry point
+├── differ_hug/            # Core computation package
+│   ├── __init__.py
+│   ├── compute.py         # Numerical computation functions
+│   ├── plotting.py        # Visualization functions
+│   ├── params.py          # Parameter serialization
+│   └── docs.py            # Documentation helpers
+└── differential_equations_streamlit_src/  # Original Streamlit code (archived)
+```
+
+## Migration Notes
+
+This is a Gradio port of the original Streamlit implementation. Key changes:
+- Replaced `streamlit` with `gradio`
+- Separated computation logic from UI
+- Preserved all numerical diagnostics
+- Made torch-based neural network solvers optional
 
 ## Citation
 
@@ -44,7 +100,8 @@ If you use this tool in your research, please cite:
 ```bibtex
 @software{differ_hug,
   author = {Krizhanovsky, Andrey},
-  title = {Differ Hug: Interactive ODE Research Platform},
+  title = {Differ Hug: ODE Research Platform},
   url = {https://huggingface.co/spaces/componavt/differ-hug},
   year = {2026}
-}
+}
+```

app.py

@@ -1,13 +1,484 @@
-import gradio as gr
+"""
+Gradio UI for the ODE Research Platform.
+
+This module implements a complete Gradio interface for the gene regulatory
+ODE system, including parameter controls, simulation execution, and
+visualization of results.
+"""
 
-def greet(name, intensity):
-    return "Hello, " + name + "!" * int(intensity)
+import gradio as gr
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import io
+import sys
+from typing import Tuple, Dict, Any
 
-demo = gr.Interface(
-    fn=greet,
-    inputs=["text", gr.Slider(value=1, minimum=1, maximum=10, step=1)],
-    outputs="text",
+from differ_hug.compute import (
+    build_angles,
+    build_initial_conditions,
+    gene_regulatory_rhs,
+    solve_trajectory_set,
+    compute_local_zscore,
+    compute_anomaly_score,
+    compute_shadowing_diagnostics,
+    SciPySolver,
 )
+from differ_hug.plotting import (
+    make_phase_portrait_figure,
+    make_time_series_figure,
+    make_shadowing_figure,
+    make_metrics_table_figure,
+)
+from differ_hug.params import parameters_to_text, text_to_parameters
+from differ_hug.docs import documentation_markdown, system_latex, get_system_description
+
+
+# Default parameter values
+DEFAULTS = {
+    "t_number": 100,
+    "t_train_end": 1.0,
+    "t_full_end": 3.0,
+    "alpha": 0.001,
+    "K": 1.0,
+    "b": 1.0,
+    "gamma1": 1.0,
+    "gamma2": 1.0,
+    "initial_radius": 0.01,
+    "num_points": 12,
+    "circle_start": 0,
+    "circle_end": 360,
+    "center_x": 1.0,
+    "center_y": 1.0,
+    "solver_type": "SciPy DOP853",
+}
+
+DEFAULT_PARAMS_TEXT = parameters_to_text(DEFAULTS)
+
+
+def run_simulation(
+    t_number: int,
+    t_train_end: float,
+    t_full_end: float,
+    alpha: float,
+    K: float,
+    b: float,
+    gamma1: float,
+    gamma2: float,
+    initial_radius: float,
+    num_points: int,
+    circle_start: int,
+    circle_end: int,
+    center_x: float,
+    center_y: float,
+    solver_type: str,
+    show_connections: bool,
+    connection_stride: int,
+    selected_indices: list,
+) -> Tuple[Any, Any, Any, Any, str, str, str, str]:
+    """
+    Run the ODE simulation and generate all outputs.
+    """
+    diagnostics = []
+    diagnostics.append("Starting simulation...")
+    
+    try:
+        diagnostics.append("Step 1: Building angles and initial conditions...")
+        angles = build_angles(num_points, circle_start, circle_end)
+        initial_conditions = build_initial_conditions(center_x, center_y, initial_radius, angles)
+        diagnostics.append(f"  Generated {len(initial_conditions)} initial conditions")
+        
+        diagnostics.append("Step 2: Creating ODE RHS function...")
+        rhs_func = gene_regulatory_rhs(alpha, K, b, gamma1, gamma2)
+        
+        diagnostics.append("Step 3: Setting up solver...")
+        if solver_type == "SciPy DOP853":
+            solver_method = "DOP853"
+        else:
+            solver_method = "RK45"
+        
+        t_full = np.linspace(0, t_full_end, t_number)
+        t_train = np.linspace(0, t_train_end, max(50, t_number // 2))
+        
+        diagnostics.append("Step 4: Solving trajectories...")
+        solutions, metrics = solve_trajectory_set(
+            rhs_func, initial_conditions, t_full, t_train, solver_method
+        )
+        diagnostics.append(f"  Successfully solved {len(solutions)} trajectories")
+        
+        if not solutions:
+            diagnostics.append("  ERROR: No trajectories solved successfully")
+            return (
+                None, None, None, None,
+                "\n".join(diagnostics),
+                DEFAULT_PARAMS_TEXT,
+                system_latex(),
+                "ERROR: No trajectories solved successfully",
+                ""
+            )
+        
+        diagnostics.append("Step 5: Computing local z-score...")
+        local_z = compute_local_zscore(metrics)
+        for i, m in enumerate(metrics):
+            m["curv_radius_local_zscore"] = float(local_z[i]) if local_z[i] is not None else np.nan
+        
+        diagnostics.append("Step 6: Computing anomaly scores...")
+        df_metrics = pd.DataFrame(metrics)
+        df_metrics["anomaly_score"] = compute_anomaly_score(df_metrics)
+        
+        diagnostics.append("Step 7: Sorting by anomaly score...")
+        df_metrics = df_metrics.sort_values(by="anomaly_score", ascending=False, na_position="last")
+        
+        diagnostics.append("Step 8: Creating figures...")
+        
+        phase_fig = make_phase_portrait_figure(
+            solutions, selected_indices, solver_type,
+            t_train_end, t_full_end, t_number,
+            show_connections, connection_stride
+        )
+        
+        time_fig = make_time_series_figure(
+            solutions, selected_indices, solver_type,
+            t_train_end, t_full_end, t_number
+        )
+        
+        shadowing_fig = None
+        if show_connections:
+            shadowing_fig = make_shadowing_figure(
+                solutions, selected_indices, solver_type,
+                t_train_end, t_full_end, t_number
+            )
+        
+        diagnostics.append("Step 9: Creating metrics table...")
+        
+        df_to_display = df_metrics.copy()
+        column_rename_map = {
+            'curv_radius_mean': 'curv_rad_mn',
+            'curv_radius_median': 'curv_rad_med',
+            'curv_radius_std': 'curv_rad_std',
+            'curv_radius_local_zscore': 'curv_rad_lcl_z',
+            'curv_count_finite': 'curv_ct_fin'
+        }
+        df_to_display = df_to_display.rename(columns=column_rename_map)
+        metrics_html = df_to_display.style.format("{:.3f}")._repr_html_()
+        
+        diagnostics.append("Step 10: Preparing outputs...")
+        params_text = parameters_to_text(locals())
+        
+        status = f"Simulation completed. Solved {len(solutions)} trajectories."
+        diagnostics.append(status)
+        
+        diagnostics_text = "\n".join(diagnostics)
+        
+        return (
+            phase_fig,
+            time_fig,
+            shadowing_fig,
+            metrics_html,
+            diagnostics_text,
+            params_text,
+            system_latex(),
+            status,
+            ""
+        )
+        
+    except Exception as e:
+        error_msg = f"ERROR: {str(e)}"
+        diagnostics.append(error_msg)
+        return (
+            None, None, None, None,
+            "\n".join(diagnostics),
+            DEFAULT_PARAMS_TEXT,
+            system_latex(),
+            error_msg,
+            ""
+        )
+
+
+def apply_text_to_controls(
+    params_text: str,
+    t_number: int,
+    t_train_end: float,
+    t_full_end: float,
+    alpha: float,
+    K: float,
+    b: float,
+    gamma1: float,
+    gamma2: float,
+    initial_radius: float,
+    num_points: int,
+    circle_start: int,
+    circle_end: int,
+    center_x: float,
+    center_y: float,
+    solver_type: str,
+) -> dict:
+    """
+    Parse text parameters and update control values.
+    """
+    parsed = text_to_parameters(params_text)
+    if not parsed:
+        return {
+            t_number: t_number, t_train_end: t_train_end, t_full_end: t_full_end,
+            alpha: alpha, K: K, b: b, gamma1: gamma1, gamma2: gamma2,
+            initial_radius: initial_radius, num_points: num_points,
+            circle_start: circle_start, circle_end: circle_end,
+            center_x: center_x, center_y: center_y, solver_type: solver_type,
+            params_text: DEFAULT_PARAMS_TEXT
+        }
+    
+    updates = {}
+    
+    int_keys = {"t_number", "num_points", "circle_start", "circle_end"}
+    float_keys = {
+        "t_train_end", "t_full_end", "alpha", "K", "b",
+        "gamma1", "gamma2", "initial_radius", "center_x", "center_y"
+    }
+    
+    for key, val in parsed.items():
+        if key in int_keys:
+            try:
+                updates[key] = int(val)
+            except Exception:
+                pass
+        elif key in float_keys:
+            try:
+                updates[key] = float(val)
+            except Exception:
+                pass
+        elif key == "solver_type":
+            updates["solver_type"] = val
+        elif key == "circle_start_end":
+            cs, ce = val
+            updates["circle_start"] = cs
+            updates["circle_end"] = ce
+    
+    if "circle_start" in parsed and "circle_end" in parsed:
+        cs = int(parsed["circle_start"])
+        ce = int(parsed["circle_end"])
+        updates["circle_start"] = cs
+        updates["circle_end"] = ce
+    
+    if "num_points" in parsed:
+        updates["selected_indices"] = list(range(min(5, int(parsed["num_points"]))))
+    
+    updates["params_text"] = parameters_to_text({**parsed, **updates})
+    
+    return updates
+
+
+def read_controls_to_text(
+    t_number: int,
+    t_train_end: float,
+    t_full_end: float,
+    alpha: float,
+    K: float,
+    b: float,
+    gamma1: float,
+    gamma2: float,
+    initial_radius: float,
+    num_points: int,
+    circle_start: int,
+    circle_end: int,
+    center_x: float,
+    center_y: float,
+    solver_type: str,
+) -> str:
+    """
+    Read current control values and convert to text format.
+    """
+    params = {
+        "t_number": int(t_number),
+        "t_train_end": float(t_train_end),
+        "t_full_end": float(t_full_end),
+        "alpha": float(alpha),
+        "K": float(K),
+        "b": float(b),
+        "gamma1": float(gamma1),
+        "gamma2": float(gamma2),
+        "initial_radius": float(initial_radius),
+        "num_points": int(num_points),
+        "circle_start": int(circle_start),
+        "circle_end": int(circle_end),
+        "center_x": float(center_x),
+        "center_y": float(center_y),
+        "solver_type": solver_type,
+    }
+    return parameters_to_text(params)
+
+
+def update_selected_indices(num_points: int, solutions_len: int) -> list:
+    """Update selected indices based on num_points."""
+    n = min(num_points, 50)
+    return list(range(min(5, n)))
+
+
+with gr.Blocks(title="Differ Hug: ODE Research Platform") as demo:
+    gr.Markdown("# Differ Hug: ODE Research Platform")
+    gr.Markdown("Interactive Gene Regulatory ODE System")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Parameters")
+            
+            t_number = gr.Slider(
+                label="t_number (time points)", minimum=10, maximum=1000, step=10,
+                value=DEFAULTS["t_number"]
+            )
+            t_train_end = gr.Slider(
+                label="t_train_end (training end)", minimum=0.1, maximum=5.0, step=0.1,
+                value=DEFAULTS["t_train_end"]
+            )
+            t_full_end = gr.Slider(
+                label="t_full_end (full integration end)", minimum=0.1, maximum=10.0, step=0.1,
+                value=DEFAULTS["t_full_end"]
+            )
+            
+            gr.Markdown("### System Parameters")
+            alpha = gr.Number(label="alpha (1/alpha exponent)", value=DEFAULTS["alpha"])
+            K = gr.Slider(label="K", minimum=0.1, maximum=5.0, step=0.1, value=DEFAULTS["K"])
+            b = gr.Number(label="b", value=DEFAULTS["b"])
+            gamma1 = gr.Number(label="gamma1", value=DEFAULTS["gamma1"])
+            gamma2 = gr.Number(label="gamma2", value=DEFAULTS["gamma2"])
+            
+            gr.Markdown("### Initial Conditions")
+            initial_radius = gr.Number(label="Initial radius (R)", value=DEFAULTS["initial_radius"])
+            num_points = gr.Slider(label="Number of trajectories", minimum=3, maximum=50, step=1,
+                                  value=DEFAULTS["num_points"])
+            circle_start = gr.Slider(label="Circle start (degrees)", minimum=0, maximum=360, step=1,
+                                    value=DEFAULTS["circle_start"])
+            circle_end = gr.Slider(label="Circle end (degrees)", minimum=0, maximum=360, step=1,
+                                  value=DEFAULTS["circle_end"])
+            center_x = gr.Number(label="Center X", value=DEFAULTS["center_x"])
+            center_y = gr.Number(label="Center Y", value=DEFAULTS["center_y"])
+            
+            gr.Markdown("### Solver Options")
+            solver_type = gr.Radio(
+                choices=["SciPy DOP853", "SciPy RK45"],
+                label="Solver Type",
+                value=DEFAULTS["solver_type"]
+            )
+            show_connections = gr.Checkbox(
+                label="Show connections (DOP853 ↔ NN)",
+                value=False
+            )
+            connection_stride = gr.Slider(
+                label="Connection stride", minimum=1, maximum=20, step=1,
+                value=5
+            )
+            
+            selected_indices = gr.CheckboxGroup(
+                label="Select trajectories to display (sorted by anomaly score)",
+                choices=[],
+                value=[],
+                interactive=True
+            )
+            
+            run_button = gr.Button("Run Simulation", variant="primary")
+            
+            gr.Markdown("### Plain Text Parameters")
+            params_text = gr.Textbox(
+                label="Parameters (edit and apply)",
+                value=DEFAULT_PARAMS_TEXT,
+                lines=3,
+                max_lines=10
+            )
+            with gr.Row():
+                apply_text_btn = gr.Button("Apply text → controls")
+                read_text_btn = gr.Button("Read controls → text")
+            
+            status_text = gr.Textbox(label="Status", lines=2)
+            
+        with gr.Column(scale=2):
+            gr.Markdown("### Outputs")
+            
+            with gr.Tabs():
+                with gr.TabItem("Phase Portrait"):
+                    phase_fig = gr.Plot(label="Phase Portrait")
+                with gr.TabItem("Time Series"):
+                    time_fig = gr.Plot(label="Time Series")
+                with gr.TabItem("Shadowing"):
+                    shadowing_fig = gr.Plot(label="Shadowing Analysis")
+                with gr.TabItem("Metrics"):
+                    metrics_df = gr.HTML(label="Metrics Table")
+                with gr.TabItem("Documentation"):
+                    documentation = gr.Markdown(documentation_markdown())
+                with gr.TabItem("System Equation"):
+                    latex_eq = gr.Markdown(system_latex())
+            
+            diagnostics_text = gr.Textbox(label="Diagnostics", lines=10)
+    
+    gr.Markdown("---")
+    gr.Markdown("**Notes:**")
+    gr.Markdown("- Anomaly score combines FTLE, path length, max curvature and R² reliability")
+    gr.Markdown("- Top 5 anomalous trajectories are selected by default")
+    
+    run_button.click(
+        fn=run_simulation,
+        inputs=[
+            t_number, t_train_end, t_full_end, alpha, K, b, gamma1, gamma2,
+            initial_radius, num_points, circle_start, circle_end,
+            center_x, center_y, solver_type, show_connections, connection_stride,
+            selected_indices
+        ],
+        outputs=[
+            phase_fig, time_fig, shadowing_fig, metrics_df,
+            diagnostics_text, params_text, latex_eq, status_text, selected_indices
+        ]
+    )
+    
+    apply_text_btn.click(
+        fn=apply_text_to_controls,
+        inputs=[
+            params_text, t_number, t_train_end, t_full_end, alpha, K, b,
+            gamma1, gamma2, initial_radius, num_points, circle_start, circle_end,
+            center_x, center_y, solver_type
+        ],
+        outputs=[
+            t_number, t_train_end, t_full_end, alpha, K, b,
+            gamma1, gamma2, initial_radius, num_points,
+            circle_start, circle_end, center_x, center_y, solver_type,
+            params_text, selected_indices
+        ]
+    )
+    
+    read_text_btn.click(
+        fn=read_controls_to_text,
+        inputs=[
+            t_number, t_train_end, t_full_end, alpha, K, b, gamma1, gamma2,
+            initial_radius, num_points, circle_start, circle_end,
+            center_x, center_y, solver_type
+        ],
+        outputs=params_text
+    )
+    
+    num_points.change(
+        fn=update_selected_indices,
+        inputs=[num_points, gr.Number(value=0, visible=False)],
+        outputs=selected_indices
+    )
+    
+    demo.load(
+        fn=lambda: (gr.update(value=DEFAULTS["t_number"]),
+                   gr.update(value=DEFAULTS["t_train_end"]),
+                   gr.update(value=DEFAULTS["t_full_end"]),
+                   gr.update(value=DEFAULTS["alpha"]),
+                   gr.update(value=DEFAULTS["K"]),
+                   gr.update(value=DEFAULTS["b"]),
+                   gr.update(value=DEFAULTS["gamma1"]),
+                   gr.update(value=DEFAULTS["gamma2"]),
+                   gr.update(value=DEFAULTS["initial_radius"]),
+                   gr.update(value=DEFAULTS["num_points"]),
+                   gr.update(value=DEFAULTS["circle_start"]),
+                   gr.update(value=DEFAULTS["circle_end"]),
+                   gr.update(value=DEFAULTS["center_x"]),
+                   gr.update(value=DEFAULTS["center_y"])),
+        outputs=[
+            t_number, t_train_end, t_full_end, alpha, K, b,
+            gamma1, gamma2, initial_radius, num_points,
+            circle_start, circle_end, center_x, center_y
+        ]
+    )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)

differ_hug/__init__.py

@@ -0,0 +1,6 @@
+"""
+differ_hug - Gradio-based ODE Research Platform
+
+This package provides a clean separation between numerical computation
+and the Gradio UI for the gene regulatory ODE system.
+"""

differ_hug/compute.py

@@ -0,0 +1,581 @@
+"""
+Core computation functions for the ODE research platform.
+
+This module contains pure computational functions that preserve the
+numerical logic from the original Streamlit implementation while
+being reusable and testable.
+"""
+
+import numpy as np
+from scipy.integrate import solve_ivp
+from typing import Tuple, List, Dict, Any, Optional
+import pandas as pd
+
+
+def build_angles(num_points: int, circle_start: float, circle_end: float) -> np.ndarray:
+    """
+    Generate angles for initial conditions on a circle or sector.
+    
+    Args:
+        num_points: Number of points to generate
+        circle_start: Starting angle in degrees (0-360)
+        circle_end: Ending angle in degrees (0-360)
+        
+    Returns:
+        Array of angles in radians
+    """
+    cs_val = circle_start % 360
+    ce_val = circle_end % 360
+    span = (ce_val - cs_val) % 360
+    
+    if np.isclose(span, 0.0):
+        angles = np.linspace(0, 2 * np.pi, num_points, endpoint=False)
+    else:
+        if ce_val >= cs_val:
+            degs = np.linspace(cs_val, ce_val, num_points, endpoint=False)
+        else:
+            span2 = (ce_val + 360) - cs_val
+            degs = (cs_val + np.linspace(0, span2, num_points, endpoint=False)) % 360
+        angles = np.deg2rad(degs)
+    
+    return angles
+
+
+def build_initial_conditions(
+    center_x: float, 
+    center_y: float, 
+    radius: float, 
+    angles: np.ndarray
+) -> List[Tuple[float, float]]:
+    """
+    Build initial conditions from center, radius, and angles.
+    
+    Args:
+        center_x: X coordinate of circle center
+        center_y: Y coordinate of circle center
+        radius: Radius of the circle
+        angles: Array of angles in radians
+        
+    Returns:
+        List of (x, y) initial condition tuples
+    """
+    initial_conditions = []
+    for angle in angles:
+        x0 = center_x + radius * np.cos(angle)
+        y0 = center_y + radius * np.sin(angle)
+        initial_conditions.append((x0, y0))
+    return initial_conditions
+
+
+def gene_regulatory_rhs(
+    alpha_val: float, 
+    K_val: float, 
+    b_val: float, 
+    g1_val: float, 
+    g2_val: float
+):
+    """
+    Create the right-hand side function for the gene regulatory ODE system.
+    
+    The system is:
+    dx/dt = (K * x^(1/alpha))/(b^(1/alpha) + x^(1/alpha)) - gamma1 * x
+    dy/dt = (K * y^(1/alpha))/(b^(1/alpha) + y^(1/alpha)) - gamma2 * y
+    
+    Args:
+        alpha_val: Alpha parameter (controls exponent)
+        K_val: K parameter
+        b_val: b parameter
+        g1_val: gamma1 parameter
+        g2_val: gamma2 parameter
+        
+    Returns:
+        RHS function suitable for scipy.integrate.solve_ivp
+    """
+    def rhs(t, state):
+        x, y = state
+        n = 1.0 / alpha_val
+        if n > 1000:
+            frac_x = K_val if x > b_val else 0.0
+            frac_y = K_val if y > b_val else 0.0
+        else:
+            x_pos, y_pos = max(x, 0.0), max(y, 0.0)
+            try:
+                pow_b = np.power(b_val, n)
+                pow_x = np.power(x_pos, n)
+                pow_y = np.power(y_pos, n)
+                frac_x = (K_val * pow_x) / (pow_b + pow_x) if np.isfinite(pow_x) else (K_val if x > b_val else 0.0)
+                frac_y = (K_val * pow_y) / (pow_b + pow_y) if np.isfinite(pow_y) else (K_val if y > b_val else 0.0)
+            except Exception:
+                frac_x, frac_y = (K_val if x > b_val else 0.0), (K_val if y > b_val else 0.0)
+        return [frac_x - g1_val * x, frac_y - g2_val * y]
+    
+    return rhs
+
+
+class SciPySolver:
+    """
+    Solver wrapper using scipy.integrate.solve_ivp.
+    """
+    DEFAULT_METHOD = 'DOP853'
+    DEFAULT_RTOL = 1e-9
+    DEFAULT_ATOL = 1e-9
+    
+    def __init__(
+        self, 
+        method: str = DEFAULT_METHOD, 
+        rtol: float = DEFAULT_RTOL, 
+        atol: float = DEFAULT_ATOL
+    ):
+        self.method = method
+        self.rtol = rtol
+        self.atol = atol
+    
+    def solve(
+        self, 
+        rhs, 
+        x0: Tuple[float, float], 
+        t_eval: np.ndarray
+    ) -> Tuple[bool, Optional[np.ndarray], Optional[np.ndarray]]:
+        """
+        Solve ODE using scipy.integrate.solve_ivp.
+        
+        Args:
+            rhs: Right-hand side function of the ODE system
+            x0: Initial conditions (x0, y0)
+            t_eval: Time points to evaluate
+            
+        Returns:
+            Tuple of (success, x_solution, y_solution)
+        """
+        try:
+            sol = solve_ivp(
+                rhs, 
+                (t_eval[0], t_eval[-1]), 
+                x0, 
+                method=self.method,
+                rtol=self.rtol, 
+                atol=self.atol, 
+                t_eval=t_eval
+            )
+            if sol.success:
+                return True, sol.y[0], sol.y[1]
+            else:
+                return False, None, None
+        except Exception:
+            return False, None, None
+
+
+def solve_trajectory_set(
+    rhs_func,
+    initial_conditions: List[Tuple[float, float]],
+    t_full: np.ndarray,
+    t_train: np.ndarray,
+    solver_method: str = 'DOP853'
+) -> Tuple[List[Dict], List[Dict]]:
+    """
+    Solve ODE for a set of initial conditions and compute metrics.
+    
+    Args:
+        rhs_func: RHS function for the ODE system
+        initial_conditions: List of (x0, y0) tuples
+        t_full: Time array for full integration
+        t_train: Time array for training interval
+        solver_method: Solver method to use ('DOP853' or 'RK45')
+        
+    Returns:
+        Tuple of (solutions, metrics) where each is a list of dicts
+    """
+    solutions = []
+    metrics = []
+    
+    solver = SciPySolver(method=solver_method)
+    
+    for idx, (x0, y0) in enumerate(initial_conditions):
+        success, x_full, y_full = solver.solve(rhs_func, (x0, y0), t_full)
+        
+        if not success or x_full is None or y_full is None:
+            solver_fallback = SciPySolver(method='RK45')
+            success, x_full, y_full = solver_fallback.solve(rhs_func, (x0, y0), t_full)
+            if not success or x_full is None or y_full is None:
+                continue
+        
+        train_success, x_train, y_train = solver.solve(rhs_func, (x0, y0), t_train)
+        if not train_success:
+            continue
+        
+        solutions.append({
+            "idx": idx,
+            "x": x_full,
+            "y": y_full,
+            "t_full": t_full,
+            "x_train": x_train,
+            "y_train": y_train,
+            "t_train": t_train,
+        })
+        
+        amp = float(np.max(np.sqrt(x_full * x_full + y_full * y_full)) - 
+                   np.min(np.sqrt(x_full * x_full + y_full * y_full)))
+        
+        ftle, final_d, ftle_r2 = compute_ftle_metrics(rhs_func, x0, y0, t_full[-1], t_full, x_full, y_full)
+        
+        hx = hurst_rs(x_full)
+        hy = hurst_rs(y_full)
+        hurst_val = np.nanmean([hx, hy])
+        
+        cr_stats = curvature_radius_stats(x_full, y_full, t_full)
+        curv_mean = cr_stats["mean"]
+        curv_median = cr_stats["median"]
+        curv_std = cr_stats["std"]
+        
+        path_len = compute_path_length(x_full, y_full)
+        
+        kappa_arr = cr_stats.get("kappa_array")
+        kappa_vals = np.array(kappa_arr) if kappa_arr is not None else np.array([])
+        kappa_vals = kappa_vals[np.isfinite(kappa_vals)] if kappa_vals.size > 0 else np.array([])
+        
+        max_kappa = float(np.nanmax(kappa_vals)) if kappa_vals.size > 0 else np.nan
+        frac_high_curv = float(np.sum(kappa_vals > 0.1) / len(t_full)) if kappa_vals.size > 0 else np.nan
+        
+        metrics.append({
+            "idx": idx,
+            "ftle": ftle,
+            "ftle_r2": ftle_r2,
+            "amp": amp,
+            "final_dist": final_d,
+            "hurst": hurst_val,
+            "curv_radius_mean": curv_mean,
+            "curv_radius_median": curv_median,
+            "curv_radius_std": curv_std,
+            "curv_p10": cr_stats["p10"],
+            "curv_p90": cr_stats["p90"],
+            "curv_count_finite": cr_stats["count_finite"],
+            "initial_x": float(x0),
+            "initial_y": float(y0),
+            "path_len": path_len,
+            "max_kappa": max_kappa,
+            "frac_high_curv": frac_high_curv,
+        })
+    
+    # Compute local z-score after all metrics are collected
+    local_z = compute_local_zscore(metrics)
+    for i, m in enumerate(metrics):
+        m["curv_radius_local_zscore"] = float(local_z[i]) if local_z[i] is not None else np.nan
+    
+    # Compute anomaly score
+    df_temp = pd.DataFrame(metrics)
+    df_temp["anomaly_score"] = compute_anomaly_score(df_temp)
+    for i, m in enumerate(metrics):
+        m["anomaly_score"] = float(df_temp.iloc[i]["anomaly_score"])
+    
+    return solutions, metrics
+
+
+def compute_ftle_metrics(
+    rhs,
+    x0: float, 
+    y0: float, 
+    te: float,
+    t_eval: np.ndarray, 
+    x: np.ndarray, 
+    y: np.ndarray
+) -> Tuple[float, float, float]:
+    """
+    Computes FTLE (Finite-Time Lyapunov Exponent) and related metrics.
+    
+    Args:
+        rhs: Right-hand side function of the ODE system
+        x0, y0: Initial conditions
+        te: End time
+        t_eval: Time points array
+        x, y: Solution arrays from the main trajectory
+        
+    Returns:
+        tuple: (ftle, final_d, ftle_r2) or (np.nan, np.nan, np.nan) if computation fails
+    """
+    eps = 1e-6 * (1.0 + abs(x0) + abs(y0))
+    xp0, yp0 = x0 + eps, y0 + 0.5 * eps
+    try:
+        sol_p = solve_ivp(rhs, (0, te), (xp0, yp0), method='DOP853', t_eval=t_eval)
+        if sol_p.success:
+            xp, yp = sol_p.y
+            dist = np.sqrt((x - xp) ** 2 + (y - yp) ** 2)
+            dist = np.where(dist <= 0, 1e-12, dist)
+            final_d = float(dist[-1])
+            s_idx, e_idx = int(0.25 * len(t_eval)), int(0.75 * len(t_eval))
+            if e_idx > s_idx + 1:
+                d_slice = dist[s_idx:e_idx]
+                t_slice = t_eval[s_idx:e_idx]
+                d_slice = np.clip(d_slice, 1e-12, None)
+                ln_d = np.log(d_slice)
+                slope, intercept = np.polyfit(t_slice, ln_d, 1)
+                ftle = float(slope)
+                resid = ln_d - (slope * t_slice + intercept)
+                ss_res = np.sum(resid ** 2)
+                ss_tot = np.sum((ln_d - np.mean(ln_d)) ** 2)
+                ftle_r2 = 1 - ss_res / ss_tot if ss_tot > 0 else np.nan
+                return ftle, final_d, ftle_r2
+        return np.nan, np.nan, np.nan
+    except Exception:
+        return np.nan, np.nan, np.nan
+
+
+def hurst_rs(ts: np.ndarray) -> float:
+    """
+    Compute the Hurst exponent using the Rescaled Range (R/S) method.
+    
+    Args:
+        ts: Time series data
+        
+    Returns:
+        float: Hurst exponent or np.nan if computation fails
+    """
+    x = np.array(ts, dtype=float)
+    N = len(x)
+    if N < 20:
+        return np.nan
+    x = x - np.mean(x)
+    Y = np.cumsum(x)
+    R = np.zeros(N)
+    S = np.zeros(N)
+    for n in range(10, N // 2 + 1):
+        seg = x[:n]
+        Yseg = Y[:n]
+        Rn = np.max(Yseg) - np.min(Yseg)
+        Sn = np.std(seg, ddof=0)
+        if Sn > 0:
+            R[n - 1] = Rn
+            S[n - 1] = Sn
+    valid = (S > 0) & (R > 0)
+    if np.sum(valid) < 3:
+        return np.nan
+    rs = R[valid] / S[valid]
+    ns = np.arange(1, N + 1)[valid]
+    try:
+        H = np.polyfit(np.log(ns), np.log(rs), 1)[0]
+    except Exception:
+        H = np.nan
+    return float(H)
+
+
+def curvature_radius_stats(
+    x: np.ndarray, 
+    y: np.ndarray, 
+    t: np.ndarray, 
+    max_radius: float = 1e6, 
+    clip_inf: bool = True
+) -> Dict[str, Any]:
+    """
+    Compute robust curvature/radius statistics for a parametric curve (x(t), y(t)).
+    
+    Args:
+        x, y: Coordinates of the curve
+        t: Parameter values
+        max_radius: Maximum radius to consider
+        clip_inf: Whether to clip infinite/very large radii
+        
+    Returns:
+        dict: Dictionary containing various curvature statistics
+    """
+    x_t = np.gradient(x, t)
+    y_t = np.gradient(y, t)
+    x_tt = np.gradient(x_t, t)
+    y_tt = np.gradient(y_t, t)
+    denom = (x_t ** 2 + y_t ** 2) ** 1.5
+    num = np.abs(x_t * y_tt - y_t * x_tt)
+    with np.errstate(divide='ignore', invalid='ignore'):
+        kappa = np.where(denom > 0, num / denom, np.nan)
+    radius = np.where(np.isfinite(kappa) & (kappa != 0), 1.0 / kappa, np.nan)
+    if clip_inf:
+        radius = np.where(radius > max_radius, np.nan, radius)
+    finite = np.isfinite(radius)
+    stats = {
+        "count_total": len(radius),
+        "count_finite": int(np.sum(finite)),
+        "frac_finite": float(np.sum(finite) / len(radius)),
+        "mean": float(np.nanmean(radius)) if np.isfinite(np.nanmean(radius)) else np.nan,
+        "median": float(np.nanmedian(radius)) if np.isfinite(np.nanmedian(radius)) else np.nan,
+        "p10": float(np.nanpercentile(radius, 10)) if np.isfinite(np.nanpercentile(radius, 10)) else np.nan,
+        "p90": float(np.nanpercentile(radius, 90)) if np.isfinite(np.nanpercentile(radius, 90)) else np.nan,
+        "std": float(np.nanstd(radius)) if np.isfinite(np.nanstd(radius)) else np.nan,
+        "radius_array": radius,
+        "kappa_array": (1.0 / radius),
+    }
+    return stats
+
+
+def compute_path_length(x: np.ndarray, y: np.ndarray) -> float:
+    """
+    Compute the total path length of a curve (x(t), y(t)).
+    
+    Args:
+        x, y: Coordinates of the curve
+        
+    Returns:
+        float: Total path length
+    """
+    dx = np.diff(x)
+    dy = np.diff(y)
+    seg_lengths = np.sqrt(dx * dx + dy * dy)
+    return float(np.sum(seg_lengths))
+
+
+def compute_local_zscore(metrics: List[Dict]) -> List[Optional[float]]:
+    """
+    Compute local z-score of curvature median versus nearest neighbors.
+    
+    Args:
+        metrics: List of metric dictionaries
+        
+    Returns:
+        List of local z-scores (or None if computation fails)
+    """
+    n = len(metrics)
+    if n <= 1:
+        return [np.nan] * n
+    
+    arr_init = np.array([[m["initial_x"], m["initial_y"]] for m in metrics])
+    rad_meds = np.array([m["curv_radius_median"] for m in metrics])
+    local_z = np.full(n, np.nan)
+    
+    try:
+        from sklearn.neighbors import NearestNeighbors
+        use_sklearn = True
+    except Exception:
+        use_sklearn = False
+    
+    if use_sklearn:
+        nbrs_k = min(5, n - 1)
+        nbrs = NearestNeighbors(n_neighbors=nbrs_k + 1).fit(arr_init)
+        distances, indices = nbrs.kneighbors(arr_init)
+        for i in range(n):
+            neigh_idx = indices[i, 1:]
+            neigh_vals = rad_meds[neigh_idx]
+            neigh_vals = neigh_vals[np.isfinite(neigh_vals)]
+            if not np.isfinite(rad_meds[i]) or len(neigh_vals) < 1:
+                local_z[i] = np.nan
+            else:
+                mu = np.mean(neigh_vals)
+                sigma = np.std(neigh_vals)
+                local_z[i] = (rad_meds[i] - mu) / sigma if sigma != 0 else np.nan
+    else:
+        nbrs_k = min(5, n - 1)
+        for i in range(n):
+            dists = np.linalg.norm(arr_init - arr_init[i : i + 1], axis=1)
+            order = np.argsort(dists)
+            neigh_idx = order[1 : 1 + nbrs_k]
+            neigh_vals = rad_meds[neigh_idx]
+            neigh_vals = neigh_vals[np.isfinite(neigh_vals)]
+            if not np.isfinite(rad_meds[i]) or len(neigh_vals) < 1:
+                local_z[i] = np.nan
+            else:
+                mu = np.mean(neigh_vals)
+                sigma = np.std(neigh_vals)
+                local_z[i] = (rad_meds[i] - mu) / sigma if sigma != 0 else np.nan
+    
+    return list(local_z)
+
+
+def robust_z(arr: np.ndarray) -> np.ndarray:
+    """
+    Compute robust z-score using median and IQR.
+    
+    Args:
+        arr: Input array
+        
+    Returns:
+        Array of robust z-scores
+    """
+    arr = np.array(arr, dtype=float)
+    finite = np.isfinite(arr)
+    out = np.full_like(arr, np.nan)
+    if np.sum(finite) == 0:
+        return out
+    median = np.nanmedian(arr[finite])
+    q1 = np.nanpercentile(arr[finite], 25)
+    q3 = np.nanpercentile(arr[finite], 75)
+    iqr = q3 - q1 if q3 - q1 != 0 else 1.0
+    out[finite] = (arr[finite] - median) / iqr
+    return out
+
+
+def compute_anomaly_score(df) -> np.ndarray:
+    """
+    Compute anomaly score combining multiple indicators.
+    
+    Uses robust z-scores (IQR-based) to combine:
+    - FTLE (higher = more anomalous)
+    - path_len (higher = more anomalous)
+    - max_kappa (higher = more anomalous)
+    - ftle_r2 (lower = more anomalous, so we subtract)
+    - hurst (higher = more anomalous)
+    
+    Args:
+        df: DataFrame with metrics
+        
+    Returns:
+        Array of anomaly scores
+    """
+    if df.empty:
+        return np.array([])
+    
+    ftle_z = robust_z(df['ftle'].values)
+    path_z = robust_z(df['path_len'].values)
+    kappa_z = robust_z(df['max_kappa'].values)
+    r2_z = robust_z(df['ftle_r2'].fillna(0).values)
+    hurst_z = robust_z(df['hurst'].fillna(0).values)
+    
+    score_arr = ftle_z + path_z + kappa_z - r2_z + hurst_z
+    return score_arr
+
+
+def compute_shadowing_diagnostics(
+    solutions: List[Dict],
+    epsilon_threshold: float = 1e-3
+) -> Dict[str, Any]:
+    """
+    Compute shadowing diagnostics comparing trajectory solutions.
+    
+    Args:
+        solutions: List of solution dictionaries (each with 'x', 'y', 't_full')
+        epsilon_threshold: Threshold for shadowing breakdown
+        
+    Returns:
+        Dictionary with shadowing diagnostics
+    """
+    epsilon_t_list = []
+    shadowing_times = []
+    
+    for sol in solutions:
+        x = sol['x']
+        y = sol['y']
+        t_full = sol['t_full']
+        
+        eps = 1e-6 * (1.0 + abs(x[0]) + abs(y[0]))
+        xp0, yp0 = x[0] + eps, y[0] + 0.5 * eps
+        try:
+            sol_p = solve_ivp(
+                lambda t, s: [0, 0], 
+                (t_full[0], t_full[-1]), 
+                (xp0, yp0), 
+                method='DOP853', 
+                t_eval=t_full
+            )
+            if sol_p.success:
+                xp, yp = sol_p.y
+                dist = np.sqrt((x - xp) ** 2 + (y - yp) ** 2)
+                epsilon_t = np.maximum.accumulate(dist)
+                epsilon_t_list.append(epsilon_t)
+                
+                exceed_indices = np.where(epsilon_t > epsilon_threshold)[0]
+                if len(exceed_indices) > 0:
+                    first_exceed_idx = exceed_indices[0]
+                    shadowing_times.append(t_full[first_exceed_idx])
+                else:
+                    shadowing_times.append(None)
+        except Exception:
+            pass
+    
+    return {
+        'epsilon_t_list': epsilon_t_list,
+        'shadowing_times': shadowing_times,
+    }

differ_hug/docs.py

@@ -0,0 +1,83 @@
+"""
+Documentation and system information for the ODE research platform.
+
+This module provides documentation text in a Gradio-friendly format.
+"""
+
+from typing import Optional
+
+
+def documentation_markdown() -> str:
+    """
+    Return documentation as Markdown text for Gradio display.
+    
+    Returns:
+        Markdown string with documentation content
+    """
+    return """---
+**Curve Annotations:**
+- Each curve is annotated with its `idx` at the final point.
+- Table shows robust curvature statistics (median, p10, p90) and path length.
+- FTLE diagnostics include R² of ln(dist) fit (ftle_r2). Anomaly score combines FTLE, path length, max curvature and R² reliability.
+
+---
+**Column Descriptions:**
+- `idx` — Index of the trajectory, starting from 0
+- `ftle` — Finite-Time Lyapunov Exponent, computed as the slope of linear fit of ln(d(t)) vs t on a central window (25%–75% of t_eval) after clipping d(t) to a minimum (1e-12)
+- `ftle_r2` — Coefficient of determination (R²) of the linear fit for FTLE, indicating reliability of the ftle estimate
+- `amp` — Amplitude (max−min of radial distance √(x²+y²))
+- `final_dist` — Final distance between the original trajectory and its companion trajectory with tiny perturbation
+- `hurst` — Hurst exponent using the rescaled range (R/S) method calculated for x(t) and y(t) and averaged
+- `curv_rad_mn` — Mean curvature radius computed from 1/κ(t) where κ(t) is the curvature
+- `curv_rad_med` — Median curvature radius computed from 1/κ(t) where κ(t) is the curvature
+- `curv_rad_std` — Standard deviation of curvature radius
+- `curv_p10` — 10th percentile of curvature radius
+- `curv_p90` — 90th percentile of curvature radius
+- `curv_ct_fin` — Number of finite radius samples
+- `initial_x` — X coordinate of the initial point
+- `initial_y` — Y coordinate of the initial point
+- `path_len` — Total arclength computed as sum of Euclidean distances between consecutive points along the trajectory
+- `max_kappa` — Maximum finite curvature value, useful to detect sharp bends
+- `frac_high_curv` — Fraction of time points with κ(t) above a threshold (default κ > 0.1, i.e., radius < 10), measuring density of sharp bends along the trajectory
+- `curv_rad_lcl_z` — Local z-score of curve median curvature radius relative to nearest neighbors in initial condition space
+- `anomaly_score` — Aggregated score combining robust z-scores (IQR-based) of ftle, path_len, max_kappa, and ftle_r2 (ftle + path_len + max_kappa − ftle_r2)
+
+---
+"""
+
+
+def system_latex() -> str:
+    """
+    Return the ODE system as LaTeX string.
+    
+    Returns:
+        LaTeX string for the gene regulatory ODE system
+    """
+    return r"""
+$$\begin{cases}
+\displaystyle \frac{dx}{dt} = \frac{K\,x^{1/\alpha}}{b^{1/\alpha} + x^{1/\alpha}} - \gamma_1\,x,\\[10pt]
+\displaystyle \frac{dy}{dt} = \frac{K\,y^{1/\alpha}}{b^{1/\alpha} + y^{1/\alpha}} - \gamma_2\,y.
+\end{cases}$$
+"""
+
+
+def get_system_description() -> str:
+    """
+    Return a brief description of the gene regulatory ODE system.
+    
+    Returns:
+        Short description string
+    """
+    return """Gene Regulatory ODE System
+
+This system models gene regulation with cooperative sigmoidal activation:
+- dx/dt = K * x^(1/alpha) / (b^(1/alpha) + x^(1/alpha)) - gamma1 * x
+- dy/dt = K * y^(1/alpha) / (b^(1/alpha) + y^(1/alpha)) - gamma2 * y
+
+Parameters:
+- alpha: Controls the steepness of the sigmoidal response (1/alpha is the Hill coefficient)
+- K: Maximum activation rate
+- b: Half-activation constant
+- gamma1, gamma2: Decay rates for x and y
+
+The system exhibits bistability and can show multiple stable states depending on parameters."""

differ_hug/params.py

@@ -0,0 +1,105 @@
+"""
+Parameter handling for the ODE research platform.
+
+This module provides functions to convert parameters to/from plain text
+format for easy sharing and editing.
+"""
+
+from typing import Dict, Any
+
+
+_ORDER = [
+    "t_number",
+    "t_train_end",
+    "t_full_end",
+    "alpha",
+    "K",
+    "b",
+    "gamma1",
+    "gamma2",
+    "initial_radius",
+    "num_points",
+    "circle_start",
+    "circle_end",
+    "center_x",
+    "center_y",
+]
+
+
+def _fmt_value(v: Any) -> str:
+    """Format numbers concisely for plain text output."""
+    if isinstance(v, bool):
+        return "1" if v else "0"
+    if isinstance(v, int):
+        return str(v)
+    try:
+        fv = float(v)
+        s = ("%g" % fv)
+        return s
+    except Exception:
+        return str(v)
+
+
+def parameters_to_text(params: Dict[str, Any]) -> str:
+    """
+    Convert parameter dictionary to plain text format.
+    
+    Args:
+        params: Dictionary of parameter names and values
+        
+    Returns:
+        Plain text string with "key=value" pairs separated by semicolons
+    """
+    parts = []
+    used = set()
+    for k in _ORDER:
+        if k in params:
+            parts.append(f"{k}={_fmt_value(params[k])}")
+            used.add(k)
+    for k, v in params.items():
+        if k not in used:
+            parts.append(f"{k}={_fmt_value(v)}")
+    return "; ".join(parts)
+
+
+def text_to_parameters(text: str) -> Dict[str, Any]:
+    """
+    Parse plain text to parameter dictionary.
+    
+    Args:
+        text: String with "key=value" pairs separated by semicolons
+        
+    Returns:
+        Dictionary with parsed parameters
+    """
+    result: Dict[str, Any] = {}
+    if not isinstance(text, str):
+        return result
+    raw = text.replace("\n", ";")
+    for chunk in raw.split(";"):
+        if "=" not in chunk:
+            continue
+        key, val = chunk.split("=", 1)
+        key = key.strip()
+        val = val.strip()
+        if not key:
+            continue
+        if val.endswith("°"):
+            val = val[:-1]
+        try:
+            if val.lower().startswith("0x"):
+                result[key] = int(val, 16)
+            else:
+                iv = int(val)
+                result[key] = iv
+                continue
+        except Exception:
+            pass
+        try:
+            fv = float(val)
+            result[key] = fv
+            continue
+        except Exception:
+            pass
+        result[key] = val
+    return result

differ_hug/plotting.py

@@ -0,0 +1,318 @@
+"""
+Plotting functions for the ODE research platform.
+
+This module provides functions to create matplotlib figures
+for phase portraits, time series, and shadowing analysis.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from typing import List, Dict, Tuple, Optional
+
+
+def make_phase_portrait_figure(
+    solutions: List[Dict],
+    selected_indices: List[int],
+    solver_type: str = "DOP853",
+    t_train_end: float = 1.0,
+    t_full_end: float = 3.0,
+    t_number: int = 100,
+    show_connections: bool = False,
+    connection_stride: int = 5,
+) -> plt.Figure:
+    """
+    Create phase portrait figure showing trajectories in phase space.
+    
+    Args:
+        solutions: List of solution dictionaries with 'x', 'y', 't_full'
+        selected_indices: List of indices to display
+        solver_type: Type of solver used
+        t_train_end: Training interval end time
+        t_full_end: Full integration end time
+        t_number: Number of time points
+        show_connections: Whether to show connections between DOP853 and NN
+        connection_stride: Stride for connection lines
+        
+    Returns:
+        matplotlib Figure object
+    """
+    fig, ax = plt.subplots(figsize=(8, 6))
+    styles = ['-', '--', '-.', ':']
+    colors = plt.cm.tab20.colors
+    
+    for m, solution_data in enumerate(solutions):
+        if m not in selected_indices:
+            continue
+        color = colors[m % len(colors)]
+        
+        x_dop = solution_data["x"]
+        y_dop = solution_data["y"]
+        ax.plot(x_dop, y_dop, linestyle='-', color=color, linewidth=1.2,
+                label=f'DOP853 traj {m}' if m == selected_indices[0] else "")
+        
+        ax.plot(x_dop[0], y_dop[0], 'o', color=color, markersize=4)
+        ax.plot(x_dop[-1], y_dop[-1], 'x', color=color, markersize=6)
+        ax.text(x_dop[-1] + 0.01, y_dop[-1] + 0.01, f"{m}", fontsize=8, color=color)
+        
+        if "x_nn" in solution_data and solution_data["x_nn"] is not None:
+            x_nn = solution_data["x_nn"]
+            y_nn = solution_data["y_nn"]
+            t_full = solution_data["t_full"]
+            
+            ax.plot(x_nn, y_nn, linestyle='--', color=color, linewidth=1.0, alpha=0.7,
+                    label=f'NN traj {m}' if m == selected_indices[0] else "")
+            
+            ax.plot(x_dop[0], y_dop[0], '^', color=color, markersize=8, markeredgecolor='black')
+            
+            if x_nn is not None and y_nn is not None:
+                train_idx = np.searchsorted(t_full, t_train_end)
+                if train_idx < len(x_dop):
+                    ax.plot(x_nn[train_idx], y_nn[train_idx], '^', color=color, markersize=8,
+                            markeredgecolor='black', markerfacecolor='none')
+                    
+                    ax.plot([x_dop[train_idx], x_nn[train_idx]],
+                            [y_dop[train_idx], y_nn[train_idx]],
+                            color=color, linewidth=1.0, alpha=0.7, linestyle=':')
+            
+            if show_connections:
+                for i in range(0, len(x_dop), connection_stride):
+                    ax.plot([x_dop[i], x_nn[i]], [y_dop[i], y_nn[i]],
+                           color=color, linewidth=0.5, alpha=0.3, linestyle='-')
+        
+        ax.text(x_dop[-1] + 0.01, y_dop[-1] + 0.01, f"{m}", fontsize=8, color=color)
+        if "x_nn" in solution_data and solution_data["x_nn"] is not None:
+            if solution_data["x_nn"] is not None:
+                ax.text(solution_data["x_nn"][-1] + 0.01, solution_data["y_nn"][-1] + 0.01,
+                        f"{m}", fontsize=8, color=color)
+    
+    ax.set_title(f"Gene regulatory trajectories ({solver_type}) "
+                 f"— t_train_end={t_train_end:.2f}, t_full_end={t_full_end:.2f}, t_points={t_number}")
+    ax.set_xlabel("x(t)")
+    ax.set_ylabel("y(t)")
+    ax.grid(True)
+    
+    if len(selected_indices) <= 3:
+        ax.legend()
+    else:
+        from matplotlib.lines import Line2D
+        legend_elements = [
+            Line2D([0], [0], color='gray', lw=2, linestyle='-', label='DOP853'),
+            Line2D([0], [0], color='gray', lw=2, linestyle='--', label='NN')
+        ]
+        ax.legend(handles=legend_elements)
+    
+    return fig
+
+
+def make_time_series_figure(
+    solutions: List[Dict],
+    selected_indices: List[int],
+    solver_type: str = "DOP853",
+    t_train_end: float = 1.0,
+    t_full_end: float = 3.0,
+    t_number: int = 100,
+) -> plt.Figure:
+    """
+    Create time series figure showing x(t) and y(t) over time.
+    
+    Args:
+        solutions: List of solution dictionaries
+        selected_indices: List of indices to display
+        solver_type: Type of solver used
+        t_train_end: Training interval end time
+        t_full_end: Full integration end time
+        t_number: Number of time points
+        
+    Returns:
+        matplotlib Figure object
+    """
+    fig, ax_ts = plt.subplots(figsize=(8, 6))
+    colors = plt.cm.tab20.colors
+    
+    for m, solution_data in enumerate(solutions):
+        if m not in selected_indices:
+            continue
+        color = colors[m % len(colors)]
+        
+        t_full = solution_data["t_full"]
+        x_dop = solution_data["x"]
+        y_dop = solution_data["y"]
+        
+        ax_ts.plot(t_full, x_dop, linestyle='-', color=color, linewidth=1.2,
+                   label=f'x(t) traj {m}' if m == selected_indices[0] else "")
+        ax_ts.plot(t_full, y_dop, linestyle='--', color=color, linewidth=1.2,
+                   label=f'y(t) traj {m}' if m == selected_indices[0] else "")
+    
+    ax_ts.set_title(f"Time series ({solver_type}) — x(t) and y(t) — "
+                    f"t_train_end={t_train_end:.2f}, t_full_end={t_full_end:.2f}, t_points={t_number}")
+    ax_ts.set_xlabel("t")
+    ax_ts.set_ylabel("x(t), y(t)")
+    ax_ts.grid(True)
+    ax_ts.legend()
+    
+    return fig
+
+
+def make_shadowing_figure(
+    solutions: List[Dict],
+    selected_indices: List[int],
+    solver_type: str = "DOP853",
+    t_train_end: float = 1.0,
+    t_full_end: float = 3.0,
+    t_number: int = 100,
+    epsilon_threshold: float = 1e-3,
+) -> Optional[plt.Figure]:
+    """
+    Create shadowing figure showing epsilon(t) vs time.
+    
+    Args:
+        solutions: List of solution dictionaries
+        selected_indices: List of indices to display
+        solver_type: Type of solver used
+        t_train_end: Training interval end time
+        t_full_end: Full integration end time
+        t_number: Number of time points
+        epsilon_threshold: Threshold for shadowing breakdown
+        
+    Returns:
+        matplotlib Figure object or None if no shadowing data available
+    """
+    if not selected_indices:
+        return None
+    
+    fig, ax_shad = plt.subplots(figsize=(8, 6))
+    colors = plt.cm.tab20.colors
+    
+    annotated = False
+    for m, solution_data in enumerate(solutions):
+        if m not in selected_indices:
+            continue
+        color = colors[m % len(colors)]
+        
+        t_full = solution_data["t_full"]
+        x_dop = solution_data["x"]
+        y_dop = solution_data["y"]
+        
+        eps = 1e-6 * (1.0 + abs(x_dop[0]) + abs(y_dop[0]))
+        xp0, yp0 = x_dop[0] + eps, y_dop[0] + 0.5 * eps
+        try:
+            from scipy.integrate import solve_ivp
+            sol_p = solve_ivp(
+                lambda t, s: [0, 0], 
+                (t_full[0], t_full[-1]), 
+                (xp0, yp0), 
+                method='DOP853', 
+                t_eval=t_full
+            )
+            if sol_p.success:
+                xp, yp = sol_p.y
+                dist = np.sqrt((x_dop - xp)**2 + (y_dop - yp)**2)
+                epsilon_t = np.maximum.accumulate(dist)
+                
+                ax_shad.plot(epsilon_t, t_full, color=color, linewidth=1.2,
+                            label=f'ε(t) traj {m}' if m == selected_indices[0] else "")
+                
+                exceed_indices = np.where(epsilon_t > epsilon_threshold)[0]
+                if len(exceed_indices) > 0:
+                    first_exceed_idx = exceed_indices[0]
+                    shadowing_time = t_full[first_exceed_idx]
+                    ax_shad.axhline(y=shadowing_time, color=color, linestyle=':', alpha=0.7,
+                                   label=f't*={shadowing_time:.2f}' if not annotated else "")
+                    annotated = True
+        except Exception:
+            pass
+    
+    ax_shad.axhline(y=t_train_end, color='red', linestyle='--', alpha=0.7,
+                   label=f't_train_end={t_train_end}')
+    
+    ax_shad.set_title(f"Shadowing ({solver_type}) — ε(t) vs t — "
+                      f"t_train_end={t_train_end:.2f}, t_full_end={t_full_end:.2f}, t_points={t_number}")
+    ax_shad.set_xlabel("ε(t)")
+    ax_shad.set_ylabel("t")
+    ax_shad.grid(True)
+    
+    if len(selected_indices) <= 3:
+        ax_shad.legend()
+    else:
+        from matplotlib.lines import Line2D
+        legend_elements = [
+            Line2D([0], [0], color='gray', lw=2, linestyle='-', label='ε(t)'),
+            Line2D([0], [0], color='red', lw=1, linestyle='--', label=f'train/extrap boundary')
+        ]
+        ax_shad.legend(handles=legend_elements)
+    
+    return fig
+
+
+def make_metrics_table_figure(
+    metrics_df,
+    show_extremes: bool = True,
+) -> plt.Figure:
+    """
+    Create a figure showing the metrics table.
+    
+    Args:
+        metrics_df: DataFrame with metrics
+        show_extremes: Whether to highlight extreme values
+        
+    Returns:
+        matplotlib Figure object
+    """
+    if metrics_df.empty:
+        fig, ax = plt.subplots(figsize=(10, 4))
+        ax.text(0.5, 0.5, "No metrics to display", ha='center', va='center', fontsize=14)
+        ax.set_axis_off()
+        return fig
+    
+    fig, ax = plt.subplots(figsize=(12, 6))
+    
+    column_rename_map = {
+        'curv_radius_mean': 'curv_rad_mn',
+        'curv_radius_median': 'curv_rad_med',
+        'curv_radius_std': 'curv_rad_std',
+        'curv_radius_local_zscore': 'curv_rad_lcl_z',
+        'curv_count_finite': 'curv_ct_fin'
+    }
+    
+    df_display = metrics_df.rename(columns=column_rename_map).copy()
+    df_display = df_display.reset_index(drop=True)
+    
+    numeric_columns = df_display.select_dtypes(include=['number']).columns.tolist()
+    
+    if show_extremes:
+        max_cols = ['idx', 'ftle', 'ftle_r2', 'amp', 'final_dist', 'hurst', 'curv_ct_fin',
+                   'path_len', 'max_kappa', 'frac_high_curv', 'anomaly_score']
+        min_cols = ['curv_rad_mn', 'curv_rad_med', 'curv_rad_std', 'curv_rad_lcl_z', 'curv_p10', 'curv_p90']
+        
+        styles = [['' for _ in range(len(df_display.columns))] for _ in range(len(df_display))]
+        
+        for i, col in enumerate(df_display.columns):
+            if col == 'idx':
+                continue
+            if col in max_cols and df_display[col].dtype in ['float64', 'int64', 'float32', 'int32']:
+                if not df_display[col].isna().all():
+                    valid = df_display[col].dropna()
+                    if len(valid) >= 2:
+                        top2 = valid.nlargest(2)
+                        for idx in top2.index:
+                            styles[idx][i] = 'background-color: #D2691E'
+                    elif len(valid) == 1:
+                        styles[valid.index[0]][i] = 'background-color: #D2691E'
+            elif col in min_cols and df_display[col].dtype in ['float64', 'int64', 'float32', 'int32']:
+                if not df_display[col].isna().all():
+                    valid = df_display[col].dropna()
+                    if len(valid) >= 2:
+                        bot2 = valid.nsmallest(2)
+                        for idx in bot2.index:
+                            styles[idx][i] = 'background-color: #00CED1'
+                    elif len(valid) == 1:
+                        styles[valid.index[0]][i] = 'background-color: #00CED1'
+        
+        df_display = df_display.style.apply(lambda x: styles, axis=None)
+    
+    ax.axis('off')
+    
+    table_str = df_display.format("{:.3f}")._repr_html_()
+    ax.text(0.01, 0.99, table_str, transform=ax.transAxes, ha='left', va='top', fontsize=8)
+    
+    return fig

requirements.txt

@@ -1,8 +1,5 @@
-gradio==4.44.1
-huggingface_hub==0.23.0
-fastapi==0.111.0
-starlette==0.37.2
-jinja2==3.1.4
+gradio>=4.44.1
 numpy>=1.24.0
 scipy>=1.10.0
-matplotlib>=3.7.0
+matplotlib>=3.7.0
+pandas>=1.5.0