+ temp old streamlit

differential_equations_streamlit_src/archive/gene_regulatory_ODE_system_read_from_pkl.py

@@ -0,0 +1,76 @@
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+# Load saved DataFrame from .pkl file
+@st.cache_data
+def load_data(path="data/013_DOP853_25radius_points171K_round3_float32.pkl"):
+    return pd.read_pickle(path)
+
+df = load_data()
+
+# Extract all unique parameter values
+alpha_list = sorted(df['alpha'].unique())
+gamma1_list = sorted(df['gamma1'].unique())
+gamma2_list = sorted(df['gamma2'].unique())
+
+# Sliders and explanation after the plot
+st.markdown("---")
+st.latex(r"""
+\begin{cases}
+\frac{dx}{dt} = \frac{K\,x^{1/\alpha}}{b^{1/\alpha} + x^{1/\alpha}} \;-\; \gamma_1\,x,\\[6pt]
+\frac{dy}{dt} = \frac{K\,y^{1/\alpha}}{b^{1/\alpha} + y^{1/\alpha}} \;-\; \gamma_2\,y.
+\end{cases}
+""")
+
+st.markdown("Select parameters to display the solution using solver DOP853.")
+
+# Selection widgets
+col1, col2, col3 = st.columns(3)
+with col1:
+    alpha = st.selectbox("Alpha (α)", options=alpha_list, format_func=lambda a: f"{a:.0e}")
+with col2:
+    gamma1 = st.slider("γ₁ (Gamma 1)", min_value=min(gamma1_list), max_value=max(gamma1_list), 
+                      value=gamma1_list[0], step=gamma1_list[1] - gamma1_list[0])
+with col3:
+    gamma2 = st.slider("γ₂ (Gamma 2)", min_value=min(gamma2_list), max_value=max(gamma2_list), 
+                      value=gamma2_list[0], step=gamma2_list[1] - gamma2_list[0])
+
+# Filter data for selected parameters
+filtered_df = df[(df['alpha'] == alpha) & (df['gamma1'] == gamma1) & (df['gamma2'] == gamma2)]
+
+# Display the plot
+fig, ax = plt.subplots(figsize=(7, 5))
+ax.set_title(f"DOP853, α={alpha:.0e}, γ₁={gamma1}, γ₂={gamma2}", fontsize=11)
+ax.set_xlabel("x(t)", fontsize=9)
+ax.set_ylabel("y(t)", fontsize=9)
+ax.grid(True, linestyle='--', linewidth=0.5)
+ax.tick_params(labelsize=8)
+ax.set_xlim(0.5, 2.0)
+ax.set_ylim(0.5, 2.0)
+
+for _, row in filtered_df.iterrows():
+    x0 = row['x0']
+    y0 = row['y0']
+    t = row['t']
+    x = row['x']
+    y = row['y']
+    label_text = f"x₀={x0:.3f}, y₀={y0:.3f}"
+    ax.plot(x, y, label=label_text, linewidth=1.5)
+    skip = max(3, len(x) // 30)
+    x_skip = x[::skip]
+    y_skip = y[::skip]
+    if len(x_skip) >= 2:
+        dx = np.gradient(x_skip)
+        dy = np.gradient(y_skip)
+        ax.quiver(x_skip, y_skip, dx, dy, angles='xy', scale_units='xy', scale=2.5, width=0.003, alpha=0.5)
+    ax.plot(x[0], y[0], marker='o', color='black', markersize=4)
+    ax.plot(x[-1], y[-1], marker='x', color='red', markersize=4)
+
+ax.legend(fontsize=7, loc='best')
+st.pyplot(fig)
+
+# Display note
+st.markdown("**Note:** The start point of the trajectory is marked with a circle (●), and the end point with a cross (×).")
+st.markdown("Initial points (x₀, y₀) are placed on a circle with radius 0.01. There are 25 such initial points in total.")

differential_equations_streamlit_src/core/integrate.py

@@ -0,0 +1,102 @@
+import numpy as np
+from scipy.integrate import solve_ivp
+
+
+# Constants for integration
+DEFAULT_SOLVER_METHOD = 'DOP853'
+DEFAULT_TOLERANCE = 1e-9
+
+
+class BaseSolver:
+    """
+    Base class for ODE solvers.
+    """
+    def solve(self, rhs, x0, t_eval):
+        raise NotImplementedError("Subclasses must implement solve method")
+
+
+class SciPySolver(BaseSolver):
+    """
+    Solver using scipy.integrate.solve_ivp
+    """
+    def __init__(self, method=DEFAULT_SOLVER_METHOD, rtol=DEFAULT_TOLERANCE, atol=DEFAULT_TOLERANCE):
+        self.method = method
+        self.rtol = rtol
+        self.atol = atol
+    
+    def solve(self, rhs, x0, t_eval):
+        """
+        Solve ODE using scipy.integrate.solve_ivp
+        
+        Args:
+            rhs: Right-hand side function of the ODE system
+            x0: Initial conditions
+            t_eval: Time points to evaluate the solution
+            
+        Returns:
+            Tuple of (solution_successful, 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
+
+
+class NeuralFlowSolver(BaseSolver):
+    """
+    Neural network solver that learns the vector field (x, y) -> (dx/dt, dy/dt)
+    """
+    def __init__(self, model=None, epochs=2000, lr=1e-3):
+        self.model = model
+        self.epochs = epochs
+        self.lr = lr
+        self.trained = False
+    
+    def train(self, rhs, x0, t_train, y_train):
+        """
+        Train the neural network to learn the vector field
+        
+        Args:
+            rhs: Right-hand side function of the ODE system (used for generating training data)
+            x0: Initial conditions
+            t_train: Time points for training
+            y_train: Target values for training (derivatives)
+        """
+        # This is a placeholder implementation - a real implementation would involve
+        # training a neural network to approximate the vector field
+        # For now, we'll just store the target data
+        self.t_train = t_train
+        self.y_train = y_train
+        self.trained = True
+    
+    def solve(self, rhs, x0, t_eval):
+        """
+        Solve ODE using the trained neural network
+        
+        Args:
+            rhs: Right-hand side function of the ODE system
+            x0: Initial conditions
+            t_eval: Time points to evaluate the solution
+            
+        Returns:
+            Tuple of (solution_successful, x_solution, y_solution)
+        """
+        if not self.trained:
+            raise ValueError("Model must be trained before solving")
+        
+        # This is a placeholder implementation
+        # A real implementation would use the trained neural network to solve the ODE
+        # For now, we'll fall back to scipy solver if model is not implemented
+        try:
+            sol = solve_ivp(rhs, (t_eval[0], t_eval[-1]), x0, method=DEFAULT_SOLVER_METHOD, 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

differential_equations_streamlit_src/core/metrics.py

@@ -0,0 +1,188 @@
+import numpy as np
+from scipy.integrate import solve_ivp
+
+
+def compute_ftle_metrics(rhs, x0, y0, te, t_eval, x, y):
+    """
+    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)
+                # linear fit and r2 diagnostics
+                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 NaN values if computation was unsuccessful
+        return np.nan, np.nan, np.nan
+    except Exception:
+        # Return NaN values in case of exception
+        return np.nan, np.nan, np.nan
+
+
+def hurst_rs(ts):
+    """
+    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, y, t, max_radius=1e6, clip_inf=True):
+    """
+    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 (values above are clipped)
+        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)  # may contain inf/nan for radius==0
+    }
+    return stats
+
+
+def compute_path_length(x, y):
+    """
+    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))
+
+
+# Constants for metrics computation
+EPSILON = 1e-12
+FTLE_START_FRAC = 0.25
+FTLE_END_FRAC = 0.75
+HURST_MIN_SIZE = 20
+CURVATURE_RADIUS_MAX = 1e6
+
+def compute_anomaly_score(ftle, path_len, max_kappa, ftle_r2, hurst=None):
+    """
+    Compute an anomaly score combining multiple indicators.
+    
+    Args:
+        ftle: Finite-Time Lyapunov Exponent
+        path_len: Path length
+        max_kappa: Maximum curvature
+        ftle_r2: R^2 of FTLE fit
+        hurst: Hurst exponent (optional)
+        
+    Returns:
+        float: Anomaly score
+    """
+    # Normalize inputs using robust z-scores (using median and IQR)
+    def robust_z_single(value, median, iqr):
+        if iqr == 0:
+            return 0.0
+        return (value - median) / iqr
+    
+    # In a real implementation, we'd compute medians and IQRs from a dataset
+    # For now, we'll use placeholder normalization factors
+    ftle_norm = ftle  # Would be normalized in practice
+    path_norm = path_len  # Would be normalized in practice
+    kappa_norm = max_kappa  # Would be normalized in practice
+    r2_norm = ftle_r2 # Would be normalized in practice
+    
+    # Basic anomaly score combining multiple indicators
+    score = ftle_norm + path_norm + kappa_norm
+    
+    # Penalize low reliability (low r2)
+    if not np.isnan(ftle_r2):
+        score -= r2_norm
+    
+    # Include Hurst exponent if provided
+    if hurst is not None and not np.isnan(hurst):
+        score += hurst  # Adjust weight as needed
+    
+    return score

differential_equations_streamlit_src/core/ode.py

@@ -0,0 +1,46 @@
+import numpy as np
+
+
+def gene_regulatory_rhs(alpha_val, K_val, b_val, g1_val, g2_val):
+    """
+    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
+    """
+    def rhs(t, state):
+        x, y = state
+        n = 1.0 / alpha_val
+        if n > 1000:
+            # Handle very large n (approaching infinity) case
+            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
+
+
+def lotka_volterra_rhs(a, b, k, m):
+    """
+    Create the right-hand side function for the Lotka-Volterra ODE system.
+    
+    The system is:
+    dx/dt = x * (a - b * y)
+    dy/dt = y * (k * b * x - m)
+    """
+    def rhs(t, state):
+        x, y = state
+        return [x * (a - b * y), y * (k * b * x - m)]
+    
+    return rhs

differential_equations_streamlit_src/core/pinn.py

@@ -0,0 +1,150 @@
+import numpy as np
+try:
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+
+if TORCH_AVAILABLE:
+    class PhysicsInformedNeuralNetwork(nn.Module):
+        """
+        Physics-Informed Neural Network (PINN) for learning the vector field of an ODE system.
+        Instead of learning the solution t -> (x(t), y(t)), this learns the vector field (x, y) -> (dx/dt, dy/dt).
+        """
+        def __init__(self, hidden_size=64):
+            super().__init__()
+            self.net = nn.Sequential(
+                nn.Linear(2, hidden_size),  # Input: (x, y)
+                nn.Tanh(),
+                nn.Linear(hidden_size, hidden_size),
+                nn.Tanh(),
+                nn.Linear(hidden_size, hidden_size),
+                nn.Tanh(),
+                nn.Linear(hidden_size, 2),  # Output: (dx/dt, dy/dt)
+            )
+
+        def forward(self, xy):
+            """
+            Forward pass: (x, y) -> (dx/dt, dy/dt)
+            """
+            return self.net(xy)
+
+
+    def train_pinn(rhs_func, x0, y0, t_train, initial_conditions=None, epochs=2000, lr=1e-3):
+        """
+        Train a PINN to learn the vector field of the ODE system.
+        
+        Args:
+            rhs_func: Right-hand side function of the ODE system that returns [dx/dt, dy/dt]
+            x0, y0: Initial conditions
+            t_train: Time points for training
+            initial_conditions: Additional initial conditions for training (optional)
+            epochs: Number of training epochs
+            lr: Learning rate
+            
+        Returns:
+            Trained PINN model
+        """
+        # Generate training data by evaluating the known RHS function
+        # This simulates having access to the derivative values for training
+        xy_train = []
+        dydt_train = []
+        
+        # For each initial condition and time point, generate training pairs
+        for t in t_train:
+            # For a PINN, we want to learn the general vector field function
+            # So we'll generate training points by evaluating the RHS at various (x,y) positions
+            # For simplicity, we'll use the actual solution points plus some variations
+            
+            # Get the solution at time t using the original solver (this is for generating training data)
+            # In a real PINN, we'd rely more on the physics constraints rather than exact solution points
+            from scipy.integrate import solve_ivp
+            sol = solve_ivp(rhs_func, (0, t), [x0, y0], method='DOP853', t_eval=[t])
+            
+            if sol.success and len(sol.y[0]) > 0:
+                x_t, y_t = sol.y[0][-1], sol.y[1][-1]
+                
+                # Evaluate the RHS at this point to get the true derivatives
+                true_derivatives = rhs_func(None, [x_t, y_t])
+                
+                # Add this as a training sample
+                xy_train.append([x_t, y_t])
+                dydt_train.append(true_derivatives)
+        
+        # Convert to tensors
+        xy_tensor = torch.tensor(xy_train, dtype=torch.float32)
+        dydt_tensor = torch.tensor(dydt_train, dtype=torch.float32)
+        
+        # Initialize model
+        model = PhysicsInformedNeuralNetwork()
+        optimizer = optim.Adam(model.parameters(), lr=lr)
+        loss_fn = nn.MSELoss()
+        
+        # Training loop
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            
+            # Predict derivatives
+            pred_dydt = model(xy_tensor)
+            
+            # Compute loss
+            loss = loss_fn(pred_dydt, dydt_tensor)
+            
+            # Backpropagate
+            loss.backward()
+            optimizer.step()
+            
+            if epoch % 500 == 0:
+                print(f"Epoch {epoch}, Loss: {loss.item():.6f}")
+        
+        return model
+
+
+    def predict_with_pinn(model, initial_condition, t_eval):
+        """
+        Solve the ODE using the trained PINN by integrating the learned vector field.
+        
+        Args:
+            model: Trained PINN model
+            initial_condition: Starting point [x0, y0]
+            t_eval: Time points to evaluate
+            
+        Returns:
+            x_pred, y_pred arrays
+        """
+        if model is None:
+            return None, None
+        
+        # Use scipy integrator with the learned vector field
+        def learned_rhs(t, state):
+            with torch.no_grad():
+                state_tensor = torch.tensor(state, dtype=torch.float32).reshape(1, -1)
+                deriv_tensor = model(state_tensor)
+                derivatives = deriv_tensor.numpy().flatten()
+            return derivatives
+        
+        from scipy.integrate import solve_ivp
+        sol = solve_ivp(learned_rhs, (t_eval[0], t_eval[-1]), initial_condition, 
+                       method='DOP853', t_eval=t_eval)
+        
+        if sol.success:
+            return sol.y[0], sol.y[1]
+        else:
+            return None, None
+else:
+    def train_pinn(rhs_func, x0, y0, t_train, initial_conditions=None, epochs=2000, lr=1e-3):
+        """
+        Placeholder function when torch is not available
+        """
+        print("PyTorch not available, skipping PINN training")
+        return None
+
+
+    def predict_with_pinn(model, initial_condition, t_eval):
+        """
+        Placeholder function when torch is not available
+        """
+        return None, None

differential_equations_streamlit_src/core/shadowing.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+
+# Constants for shadowing analysis
+SHADOWING_EPSILON_THRESHOLD = 1e-3
+
+
+def compute_epsilon_t(distances):
+    """
+    Compute epsilon(t) as the running maximum of distances.
+    
+    Args:
+        distances: Array of distances between two trajectories at each time point
+        
+    Returns:
+        Array representing epsilon(t) - the running maximum of distances
+    """
+    return np.maximum.accumulate(distances)
+
+
+def find_shadowing_breakdown_time(epsilon_t, t_eval, epsilon_threshold=SHADOWING_EPSILON_THRESHOLD):
+    """
+    Find the shadowing breakdown time t* where epsilon(t) exceeds a threshold.
+    
+    Args:
+        epsilon_t: Array of epsilon(t) values (running maximum of distances)
+        t_eval: Time points corresponding to epsilon(t) values
+        epsilon_threshold: Threshold above which shadowing is considered broken
+        
+    Returns:
+        tuple: (shadowing_time, shadowing_length, shadowing_ratio)
+               shadowing_time: Time t* where epsilon(t) > epsilon_threshold (or None if never exceeded)
+               shadowing_length: Length of time where epsilon(t) <= epsilon_threshold
+               shadowing_ratio: Ratio of valid shadowing time to total time
+    """
+    if len(epsilon_t) != len(t_eval):
+        raise ValueError("epsilon_t and t_eval must have the same length")
+    
+    # Find the first time where epsilon(t) exceeds the threshold
+    exceed_indices = np.where(epsilon_t > epsilon_threshold)[0]
+    
+    if len(exceed_indices) == 0:
+        # If threshold is never exceeded, shadowing holds for the entire duration
+        shadowing_time = None  # Indicates no breakdown occurred
+        shadowing_length = t_eval[-1] - t_eval[0]
+        shadowing_ratio = 1.0
+    else:
+        # Take the first occurrence where threshold is exceeded
+        first_exceed_idx = exceed_indices[0]
+        shadowing_time = t_eval[first_exceed_idx]
+        shadowing_length = t_eval[first_exceed_idx] - t_eval[0]
+        shadowing_ratio = shadowing_length / (t_eval[-1] - t_eval[0])
+    
+    return shadowing_time, shadowing_length, shadowing_ratio
+
+
+def compute_shadowing_diagnostics(dop_solution, nn_solution, t_eval, epsilon_threshold=SHADOWING_EPSILON_THRESHOLD):
+    """
+    Compute comprehensive shadowing diagnostics by comparing two solutions.
+    
+    Args:
+        dop_solution: Dictionary with 'x' and 'y' arrays from DOP853 solver
+        nn_solution: Dictionary with 'x' and 'y' arrays from neural network solver
+        t_eval: Time points array
+        epsilon_threshold: Threshold for shadowing breakdown
+        
+    Returns:
+        dict: Dictionary containing shadowing diagnostics
+    """
+    # Calculate distance between DOP853 and NN solutions
+    dist = np.sqrt((dop_solution['x'] - nn_solution['x'])**2 + (dop_solution['y'] - nn_solution['y'])**2)
+    
+    # Calculate epsilon(t) as the running maximum (sup norm)
+    epsilon_t = compute_epsilon_t(dist)
+    
+    # Calculate shadowing breakdown diagnostics
+    shadowing_time, shadowing_length, shadowing_ratio = find_shadowing_breakdown_time(
+        epsilon_t, t_eval, epsilon_threshold
+    )
+    
+    return {
+        'epsilon_t': epsilon_t,
+        'distances': dist,
+        'shadowing_time': shadowing_time,
+        'shadowing_length': shadowing_length,
+        'shadowing_ratio': shadowing_ratio,
+        'epsilon_threshold': epsilon_threshold,
+        'has_breakdown': shadowing_time is not None
+    }

differential_equations_streamlit_src/gene_regulatory_ODE_system.py

@@ -0,0 +1,627 @@
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+import pandas as pd
+
+from core.ode import gene_regulatory_rhs
+from core.integrate import SciPySolver, NeuralFlowSolver
+from core.metrics import compute_ftle_metrics, hurst_rs, curvature_radius_stats, compute_path_length, compute_anomaly_score
+from core.shadowing import compute_shadowing_diagnostics
+from core.pinn import train_pinn, predict_with_pinn
+from utils.plain_text_parameters import parameters_to_text, text_to_parameters
+from utils.highlight_extreme_values_in_table import highlight_extreme_values_in_table
+import streamlit.components.v1 as components
+
+# --------------------------------------------------
+# Main Streamlit App for Gene Regulatory ODE System
+# --------------------------------------------------
+
+# Default parameter values
+DEFAULTS = {
+    "alpha": 0.001,
+    "K": 1.0,
+    "b": 1.0,
+    "gamma1": 1.0,
+    "gamma2": 1.0,
+    "initial_radius": 0.01,
+    "num_points": 12,
+    "t_number": 100,
+    "t_train_end": 1.0,
+    "t_full_end": 3.0,
+    "circle_start_end": (0, 360),
+}
+
+# --- Sidebar: widgets ---
+st.sidebar.header("Simulation Settings")
+
+# Time / solver resolution
+t_number = st.sidebar.slider("t_number", min_value=10, max_value=1000, step=10,
+                             value=int(DEFAULTS["t_number"]))
+t_train_end = st.sidebar.slider("Training interval end (t_train_end)", 0.1, 5.0, float(DEFAULTS["t_train_end"]), 0.1)
+t_full_end = st.sidebar.slider("Full integration end (t_full_end)", t_train_end + 0.1, 10.0, float(DEFAULTS["t_full_end"]), 0.1)
+
+alpha = st.sidebar.number_input("alpha (1/alpha exponent)", min_value=1e-9, max_value=10.0,
+                                value=float(DEFAULTS["alpha"]), format="%g")
+K = st.sidebar.slider("K", min_value=0.1, max_value=5.0, step=0.1,
+                       value=float(DEFAULTS["K"]))
+b = st.sidebar.number_input("b", min_value=0.0, max_value=10.0,
+                             value=float(DEFAULTS["b"]), format="%g")
+
+gamma1 = st.sidebar.number_input("gamma1", min_value=0.0, max_value=10.0,
+                                 value=float(DEFAULTS["gamma1"]), format="%g")
+gamma2 = st.sidebar.number_input("gamma2", min_value=0.0, max_value=10.0,
+                                 value=float(DEFAULTS["gamma2"]), format="%g")
+
+initial_radius = st.sidebar.number_input("Initial radius (R)", min_value=0.0, max_value=10.0,
+                                         value=float(DEFAULTS["initial_radius"]), format="%g")
+num_points = st.sidebar.slider("Number of trajectories", min_value=3, max_value=50, step=1,
+                               value=int(DEFAULTS["num_points"]))
+
+circle_start_end = st.sidebar.slider("Sector on circle (degrees)", 0, 360,
+                                      tuple(map(int, DEFAULTS["circle_start_end"])), step=1)
+
+# Add controllable center of the initial circle
+center_x = st.sidebar.number_input("Center X (circle center)", value=float(b), format="%g")
+center_y = st.sidebar.number_input("Center Y (circle center)", value=float(b), format="%g")
+
+# Add solver selection
+solver_type = st.sidebar.selectbox(
+    "Select Solver Type",
+    ("SciPy DOP853", "PINN (Physics-Informed Neural Network)"),
+    index=0,
+    help="Choose the solver for the ODE system"
+)
+
+# --- Plain text area and two buttons ---
+
+def collect_params_from_widgets():
+    cs, ce = circle_start_end
+    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(cs),
+        "circle_end": int(ce),
+        "center_x": float(center_x),
+        "center_y": float(center_y),
+        "solver_type": solver_type,
+    }
+    # Save only enabled checkboxes if available
+    if "enabled_checkboxes" in st.session_state:
+        enabled = st.session_state.enabled_checkboxes
+        if enabled:
+            params["enabled_idx"] = ",".join(map(str, enabled))
+    return params
+
+if "params_text" not in st.session_state:
+    st.session_state.params_text = parameters_to_text(collect_params_from_widgets())
+
+st.sidebar.markdown("**Parameters (plain text)**")
+params_text = st.sidebar.text_area("Edit parameters here:", value=st.session_state.params_text, height=20, key="params_text")
+
+# Callback: parse text and apply to widgets
+def apply_text_to_sliders():
+    parsed = text_to_parameters(st.session_state.params_text)
+    if not parsed:
+        return
+    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:
+                st.session_state[key] = int(val)
+            except Exception:
+                pass
+        elif key in float_keys:
+            try:
+                st.session_state[key] = float(val)
+            except Exception:
+                pass
+        elif key == "enabled_idx":
+            enabled_idx = [int(x) for x in str(val).split(",") if x.strip().isdigit()]
+            npts = int(parsed.get("num_points", st.session_state.get("num_points", num_points)))
+            enabled_idx = [i for i in enabled_idx if 0 <= i < npts]
+            st.session_state.enabled_checkboxes = enabled_idx
+        elif key == "solver_type":
+            st.session_state["solver_type"] = val
+
+    if "circle_start" in parsed or "circle_end" in parsed:
+        cs = int(parsed.get("circle_start", circle_start_end[0]))
+        ce = int(parsed.get("circle_end", circle_start_end[1]))
+        st.session_state.circle_start_end = (cs, ce)
+
+    if "num_points" in parsed:
+        npts = int(parsed["num_points"])
+        enabled = st.session_state.get("enabled_checkboxes", [])
+        st.session_state.enabled_checkboxes = [i for i in enabled if 0 <= i < npts]
+
+    st.session_state.params_text = parameters_to_text(collect_params_from_widgets())
+
+# Callback: read widget values and put into text area
+def read_sliders_to_text():
+    st.session_state.params_text = parameters_to_text(collect_params_from_widgets())
+
+col_apply, col_read = st.sidebar.columns(2)
+col_apply.button("Apply text → sliders", on_click=apply_text_to_sliders)
+col_read.button("Read sliders → text", on_click=read_sliders_to_text)
+
+# --- Build angle array ---
+cs_val, ce_val = circle_start_end
+span = (ce_val - cs_val) % 360
+if np.isclose(span, 0.0):
+    angles = np.linspace(0, 2 * np.pi, num_points, endpoint=False)
+else:
+    cs = cs_val % 360
+    ce = ce_val % 360
+    if ce >= cs:
+        degs = np.linspace(cs, ce, num_points, endpoint=False)
+    else:
+        span2 = (ce + 360) - cs
+        degs = (cs + np.linspace(0, span2, num_points, endpoint=False)) % 360
+    angles = np.deg2rad(degs)
+
+# --- Prepare solver settings ---
+alpha_val = float(alpha)
+K_val = float(K)
+b_val = float(b)
+g1_val = float(gamma1)
+g2_val = float(gamma2)
+R_val = float(initial_radius)
+
+tn = int(t_number)
+tte = float(t_train_end)
+tfe = float(t_full_end)
+
+# --- Create initial conditions from parameters ---
+initial_conditions = []
+for angle in angles:
+    x0 = center_x + R_val * np.cos(angle)
+    y0 = center_y + R_val * np.sin(angle)
+    initial_conditions.append((x0, y0))
+
+# --- Create ODE RHS function ---
+rhs_func = gene_regulatory_rhs(alpha_val, K_val, b_val, g1_val, g2_val)
+
+# --- Main computation ---
+solutions, metrics = [], []
+
+# Main loop: solve for each initial condition
+for idx, (x0, y0) in enumerate(initial_conditions):
+    # Solve ODE on full interval [0, t_full_end]
+    t_eval_full = np.linspace(0, tfe, tn)
+    
+    # Select and configure solver
+    if solver_type == "SciPy DOP853":
+        solver = SciPySolver(method='DOP853')
+        success, x_full, y_full = solver.solve(rhs_func, (x0, y0), t_eval_full)
+    else:  # PINN
+        # For PINN, we need to train first on the full interval
+        solver = NeuralFlowSolver()  # Placeholder - in reality, PINN would be handled differently
+        # For now, we'll use SciPy solver as fallback and note that PINN implementation is more complex
+        scipy_solver = SciPySolver(method='DOP853')
+        success, x_full, y_full = scipy_solver.solve(rhs_func, (x0, y0), t_eval_full)
+        
+        # Train PINN separately if needed
+        try:
+            pinn_model = train_pinn(rhs_func, x0, y0, t_eval_full, epochs=1000)
+            pinn_x_full, pinn_y_full = predict_with_pinn(pinn_model, [x0, y0], t_eval_full)
+        except Exception as e:
+            st.warning(f"PINN training failed: {str(e)}, falling back to SciPy solver")
+            pinn_x_full, pinn_y_full = x_full, y_full
+
+    if not success or x_full is None or y_full is None:
+        # If primary solver failed, try alternative
+        scipy_solver = SciPySolver(method='RK45')
+        success, x_full, y_full = scipy_solver.solve(rhs_func, (x0, y0), t_eval_full)
+        if not success or x_full is None or y_full is None:
+            st.warning(f"Solver failed for initial condition {idx}: ({x0}, {y0})")
+            continue
+
+    # For PINN, use the PINN solution if available
+    if solver_type == "PINN (Physics-Informed Neural Network)" and 'pinn_x_full' in locals():
+        x_full, y_full = pinn_x_full, pinn_y_full
+
+    # Get solution on training interval [0, t_train_end] for neural network training
+    t_eval_train = np.linspace(0, tte, max(50, tn//2))  # Use fewer points for training
+    scipy_train_solver = SciPySolver(method='DOP853')
+    train_success, x_train, y_train = scipy_train_solver.solve(rhs_func, (x0, y0), t_eval_train)
+    if not train_success:
+        continue
+
+    # Train neural network on [0, t_train_end] - keeping the original neural ODE approach
+    from utils.neural_ode_solver import train_neural_ode, predict_with_neural_ode
+    nn_model = train_neural_ode(t_eval_train, x_train, y_train, epochs=10)
+    x_nn_full, y_nn_full = predict_with_neural_ode(nn_model, t_eval_full)
+
+    # Store solutions for plotting
+    solutions.append({
+        "dop853_x": x_full,
+        "dop853_y": y_full,
+        "nn_x": x_nn_full,
+        "nn_y": y_nn_full,
+        "t_full": t_eval_full
+    })
+
+    # Calculate metrics using the primary solution on the full interval
+    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, tfe, t_eval_full, x_full, y_full)
+
+    # Hurst: compute for x and y and take mean
+    hx = hurst_rs(x_full)
+    hy = hurst_rs(y_full)
+    hurst_val = np.nanmean([hx, hy])
+
+    # curvature radius stats
+    cr_stats = curvature_radius_stats(x_full, y_full, t_eval_full)
+    curv_mean = cr_stats["mean"]
+    curv_median = cr_stats["median"]
+    curv_std = cr_stats["std"]
+
+    # path length
+    path_len = compute_path_length(x_full, y_full)
+
+    # maximum curvature (kappa) and fraction of high curvature points
+    kappa_arr = cr_stats.get("kappa_array")
+    # kappa_array may include inf/nan; handle robustly
+    kappa_vals = np.array(kappa_arr)
+    kappa_vals = kappa_vals[np.isfinite(kappa_vals)] if kappa_vals is not None else np.array([])
+    max_kappa = float(np.nanmax(kappa_vals)) if kappa_vals.size > 0 else np.nan
+    # fraction of points with radius < 10 -> kappa > 0.1 (example threshold)
+    frac_high_curv = float(np.sum(kappa_vals > 0.1) / len(t_eval_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 of curvature median versus nearest neighbours (fallback without sklearn available)
+try:
+    from sklearn.neighbors import NearestNeighbors
+    use_sklearn = True
+except Exception:
+    use_sklearn = False
+
+if metrics:
+    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(len(metrics), np.nan)
+    if len(metrics) > 1:
+        nbrs_k = min(5, len(metrics) - 1)
+        if use_sklearn:
+            nbrs = NearestNeighbors(n_neighbors=nbrs_k + 1).fit(arr_init)
+            distances, indices = nbrs.kneighbors(arr_init)
+            for i in range(len(metrics)):
+                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:
+            for i in range(len(metrics)):
+                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
+    for i in range(len(metrics)):
+        metrics[i]["curv_radius_local_zscore"] = float(local_z[i]) if np.isfinite(local_z[i]) else np.nan
+
+# Build dataframe
+df_metrics = pd.DataFrame(metrics)
+
+# --- Compute anomaly score (combine multiple indicators) ---
+# Prepare columns for scoring: ftle (higher), path_len (higher), max_kappa (higher), ftle_r2 (higher means reliable)
+# We'll compute robust z-scores (subtract median, divide by IQR) to avoid influence of outliers
+
+def robust_z(arr):
+    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
+
+if not df_metrics.empty:
+    ftle_z = robust_z(df_metrics['ftle'].values)
+    path_z = robust_z(df_metrics['path_len'].values)
+    kappa_z = robust_z(df_metrics['max_kappa'].values)
+    r2_z = robust_z(df_metrics['ftle_r2'].fillna(0).values)
+    hurst_z = robust_z(df_metrics['hurst'].fillna(0).values)
+    # score = ftle_z + path_z + kappa_z - r2_z + hurst_z (penalize low r2 by subtracting its z, include hurst)
+    score_arr = ftle_z + path_z + kappa_z - r2_z + hurst_z
+    df_metrics['anomaly_score'] = score_arr
+
+# --- Selection UI (checkbox list, sorted by anomaly_score desc) ---
+selected_idx = []
+st.sidebar.markdown("**Select trajectories to display (sorted by anomaly score)**")
+
+# Checkbox for connecting lines between DOP853 and NN
+show_connections = st.sidebar.checkbox("Show connections (DOP853 ↔ NN)", value=False, key="show_connections")
+
+# Connection stride parameter
+if show_connections:
+    connection_stride = st.sidebar.slider("Connection stride", min_value=1, max_value=20, value=5, step=1)
+else:
+    connection_stride = 5  # default value when not showing connections
+
+if not df_metrics.empty:
+    df_sorted = df_metrics.sort_values(by="anomaly_score", ascending=False, na_position="last")
+    
+    # Master checkbox to hide all trajectories
+    hide_all = st.sidebar.checkbox("Hide all trajectories", value=True, key="hide_all_trajectories")
+    
+    selected_idx = []
+    new_enabled = []
+    
+    for m, row in df_sorted.iterrows():
+        idx = int(row["idx"])
+        # Updated label to include Hurst exponent
+        label = f"{idx}: H={row.get('hurst', np.nan):.3g} | score={row.get('anomaly_score', np.nan):.3g}, FTLE={row.get('ftle', np.nan):.3g}"
+        
+        checked = st.sidebar.checkbox(
+            label,
+            value=(idx in st.session_state.get("enabled_checkboxes", [])),
+            key=f"traj_{idx}"
+        )
+        
+        if checked:
+            new_enabled.append(idx)
+            selected_idx.append(idx)
+    
+    # FINAL FILTER: if hide_all is True, clear selected_idx
+    if hide_all:
+        selected_idx = []
+    
+    st.session_state.enabled_checkboxes = new_enabled
+
+# --- Plot trajectories ---
+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_idx:
+        continue
+    color = colors[m % len(colors)]
+    
+    # Plot DOP853 solution (solid line)
+    x_dop = solution_data["dop853_x"]
+    y_dop = solution_data["dop853_y"]
+    ax.plot(x_dop, y_dop, linestyle='-', color=color, linewidth=1.2, label=f'DOP853 traj {m}' if m == selected_idx[0] else "")
+
+    # Plot Neural Network solution on full interval (dashed line)
+    if solution_data["nn_x"] is not None and solution_data["nn_y"] is not None:
+        x_nn = solution_data["nn_x"]
+        y_nn = solution_data["nn_y"]
+        t_full = solution_data["t_full"]
+        
+        # Plot NN solution as dashed line throughout the full interval
+        ax.plot(x_nn, y_nn, linestyle='--', color=color, linewidth=1.0, alpha=0.7, label=f'NN traj {m}' if m == selected_idx[0] else "")
+    
+    # Mark initial and final points
+    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)
+    
+    # Mark t_train_end point with a triangle for both DOP853 and NN
+    train_idx = np.searchsorted(t_full, tte)
+    if train_idx < len(x_dop):
+        ax.plot(x_dop[train_idx], y_dop[train_idx], '^', color=color, markersize=8, markeredgecolor='black')
+        # Also mark the corresponding point on NN curve
+        if x_nn is not None and y_nn is not None and train_idx < len(x_nn):
+            ax.plot(x_nn[train_idx], y_nn[train_idx], '^', color=color, markersize=8, markeredgecolor='black', markerfacecolor='none')
+            
+            # Always draw line between triangles at t_train_end regardless of show_connections setting
+            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 showing connections, draw lines between DOP853 and NN points
+        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='-')
+    
+    # Add trajectory number label near the end point for both curves
+    ax.text(x_dop[-1] + 0.01, y_dop[-1] + 0.01, f"{m}", fontsize=8, color=color)
+    if x_nn is not None and y_nn is not None:
+        ax.text(x_nn[-1] + 0.01, y_nn[-1] + 0.01, f"{m}", fontsize=8, color=color)
+
+ax.set_title(f"Gene regulatory trajectories ({solver_type}) — t_train_end={tte:.2f}, t_full_end={tfe:.2f}, t_points={tn}")
+ax.set_xlabel("x(t)")
+ax.set_ylabel("y(t)")
+ax.grid(True)
+# Only show legend if there are few trajectories to avoid clutter
+if len(selected_idx) <= 3:
+    ax.legend()
+else:
+    # Create custom legend with unique labels
+    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)
+st.pyplot(fig)
+
+# --- Time series plot: x(t) and y(t) ---
+fig_ts, ax_ts = plt.subplots(figsize=(8, 6))
+
+for m, solution_data in enumerate(solutions):
+    if m not in selected_idx:
+        continue
+    color = colors[m % len(colors)]
+    
+    t_full = solution_data["t_full"]
+    x_dop = solution_data["dop853_x"]
+    y_dop = solution_data["dop853_y"]
+    
+    # Plot x(t) as solid line and y(t) as dashed line
+    ax_ts.plot(t_full, x_dop, linestyle='-', color=color, linewidth=1.2, label=f'x(t) traj {m}' if m == selected_idx[0] else "")
+    ax_ts.plot(t_full, y_dop, linestyle='--', color=color, linewidth=1.2, label=f'y(t) traj {m}' if m == selected_idx[0] else "")
+
+ax_ts.set_title(f"Time series ({solver_type}) — x(t) and y(t) — t_train_end={tte:.2f}, t_full_end={tfe:.2f}, t_points={tn}")
+ax_ts.set_xlabel("t")
+ax_ts.set_ylabel("x(t), y(t)")
+ax_ts.grid(True)
+ax_ts.legend()
+st.pyplot(fig_ts)
+
+# --- Shadowing plot: epsilon(t) ---
+if show_connections:
+    # Import shadowing functionality
+    from core.shadowing import compute_epsilon_t, find_shadowing_breakdown_time
+    
+    fig_shad, ax_shad = plt.subplots(figsize=(8, 6))
+    
+    for m, solution_data in enumerate(solutions):
+        if m not in selected_idx:
+            continue
+        color = colors[m % len(colors)]
+        
+        t_full = solution_data["t_full"]
+        x_dop = solution_data["dop853_x"]
+        y_dop = solution_data["dop853_y"]
+        x_nn = solution_data["nn_x"]
+        y_nn = solution_data["nn_y"]
+        
+        # Calculate distance between DOP853 and NN solutions
+        dist = np.sqrt((x_dop - x_nn)**2 + (y_dop - y_nn)**2)
+        # Calculate epsilon(t) as the running maximum (sup norm)
+        epsilon_t = compute_epsilon_t(dist)
+        
+        ax_shad.plot(epsilon_t, t_full, color=color, linewidth=1.2, label=f'ε(t) traj {m}' if m == selected_idx[0] else "")
+        
+        # Calculate and annotate shadowing breakdown time
+        shadowing_time, shadowing_length, shadowing_ratio = find_shadowing_breakdown_time(epsilon_t, t_full)
+        if shadowing_time is not None:
+            ax_shad.axhline(y=shadowing_time, color=color, linestyle=':', alpha=0.7, label=f't*={shadowing_time:.2f} traj {m}')
+    
+    # Add vertical line to indicate the transition from training to extrapolation
+    ax_shad.axhline(y=tte, color='red', linestyle='--', alpha=0.7, label=f't_train_end={tte}')
+    
+    ax_shad.set_title(f"Shadowing ({solver_type}) — ε(t) vs t — t_train_end={tte:.2f}, t_full_end={tfe:.2f}, t_points={tn}")
+    ax_shad.set_xlabel("ε(t)")
+    ax_shad.set_ylabel("t")
+    ax_shad.grid(True)
+    # Only show legend if there are few trajectories to avoid clutter
+    if len(selected_idx) <= 3:
+        ax_shad.legend()
+    else:
+        # Create custom legend with unique labels
+        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)
+    st.pyplot(fig_shad)
+    
+    # Display shadowing diagnostics
+    st.markdown("**Shadowing Diagnostics:**")
+    shadowing_diagnostics_text = ""
+    for m, solution_data in enumerate(solutions):
+        if m not in selected_idx:
+            continue
+        
+        t_full = solution_data["t_full"]
+        x_dop = solution_data["dop853_x"]
+        y_dop = solution_data["dop853_y"]
+        x_nn = solution_data["nn_x"]
+        y_nn = solution_data["nn_y"]
+        
+        # Calculate distance between DOP853 and NN solutions
+        dist = np.sqrt((x_dop - x_nn)**2 + (y_dop - y_nn)**2)
+        # Calculate epsilon(t) as the running maximum (sup norm)
+        epsilon_t = compute_epsilon_t(dist)
+        
+        # Calculate shadowing breakdown diagnostics
+        shadowing_time, shadowing_length, shadowing_ratio = find_shadowing_breakdown_time(epsilon_t, t_full)
+        
+        if shadowing_time is not None:
+            shadowing_diagnostics_text += f"Trajectory {m}: t* = {shadowing_time:.3f}, length = {shadowing_length:.3f}, ratio = {shadowing_ratio:.3f}\n"
+        else:
+            shadowing_diagnostics_text += f"Trajectory {m}: No breakdown (ε(t) ≤ threshold for entire duration)\n"
+    
+    if shadowing_diagnostics_text:
+        st.text(shadowing_diagnostics_text)
+
+# --- Show info about solvers ---
+st.info(f"DOP853 solved on full interval [0, {tfe:.2f}], NN (Feedforward) trained on [0, {tte:.2f}] and applied to full interval [0, {tfe:.2f}]")
+
+# --- Show metrics table (rounded) ---
+st.markdown("**Per-trajectory metrics (rounded to 3 decimals)**")
+if not df_metrics.empty:
+    df_to_display = df_metrics.reset_index(drop=True)
+    
+    # Create a copy of the dataframe with shorter column names for display purposes
+    df_display_shortened = df_to_display.copy()
+    
+    # Define mapping for shortened column names (only for long 'curv_' columns)
+    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'
+        # Note: curv_p10 and curv_p90 are already short
+    }
+    
+    df_display_shortened = df_display_shortened.rename(columns=column_rename_map)
+    
+    # Format only numeric columns, keeping 'idx' as integer
+    numeric_columns = df_display_shortened.select_dtypes(include=[np.number]).columns.tolist()
+    formatter = {col: "{:.3f}" for col in numeric_columns}
+    
+    # Apply styling - note that our highlight function now supports both original and shortened names
+    styled_df = df_display_shortened.style.format(formatter).apply(highlight_extreme_values_in_table, axis=None)
+    
+    st.dataframe(styled_df)
+
+# CSV export with rounding
+if not df_metrics.empty:
+    csv_name = "export_metrics_rounded.csv"
+    df_metrics.round(3).to_csv(csv_name, index=False, float_format="%.3f")
+    st.download_button("Download metrics CSV (rounded)", data=open(csv_name, 'rb'), file_name=csv_name)
+
+st.markdown("**Parameters currently used:**")
+st.text(parameters_to_text(collect_params_from_widgets()))
+
+# Import the documentation function
+from utils.documentation import display_ode_documentation
+
+# Display the ODE system documentation
+display_ode_documentation()

differential_equations_streamlit_src/pages/1_Lotka-Volterra.py

@@ -0,0 +1,78 @@
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.integrate import solve_ivp
+
+# Sidebar controls
+st.sidebar.header("Simulation Settings")
+# Sliders for parameters a, b, k, m
+a = st.sidebar.slider("Prey growth rate a", min_value=0.0, max_value=2.0, step=0.1, value=0.2)
+b = st.sidebar.slider("Predation rate b", min_value=0.0, max_value=2.0, step=0.1, value=0.2)
+k = st.sidebar.slider("Predator efficiency k", min_value=0.0, max_value=2.0, step=0.1, value=0.5)
+m = st.sidebar.slider("Predator death rate m", min_value=0.0, max_value=2.0, step=0.1, value=0.1)
+# End time slider from 1 to 50
+t_end = st.sidebar.slider("End time (t_end)", min_value=1, max_value=50, step=1, value=35)
+
+# Number of evaluation points and time array
+N = 500
+t_eval = np.linspace(0, t_end, N)
+
+# Solver choice
+method = "DOP853"
+
+# Initial conditions for prey (x0) and predator y0
+x0_values = np.arange(1.0, 2.01, 0.1)
+y0 = 1.0
+
+# Compute trajectories without caching (to reflect t_end changes)
+def compute_trajectories(params):
+    a_, b_, k_, m_ = params
+    trajs = []
+    for x0 in x0_values:
+        def lv_system(t, z):
+            x, y = z
+            return [x * (a_ - b_ * y), y * (k_ * b_ * x - m_)]
+        sol = solve_ivp(lv_system, (0, t_end), [x0, y0], method=method, t_eval=t_eval)
+        trajs.append(sol.y)
+    return trajs
+
+trajectories = compute_trajectories((a, b, k, m))
+
+# Plot static phase trajectories
+fig, ax = plt.subplots(figsize=(8, 6))
+title = f"Lotka–Volterra (a={a}, b={b}, k={k}, m={m}; t_end={t_end})"
+ax.set_title(title, fontsize=14)
+ax.set_xlabel("Prey population x(t)")
+ax.set_ylabel("Predator population y(t)")
+ax.grid(True, linestyle='--', linewidth=0.5)
+
+for idx, (x, y) in enumerate(trajectories):
+    ax.plot(x, y, linewidth=1.0)
+    ax.plot(x[0], y[0], 'o', color='black', markersize=4)
+    ax.plot(x[-1], y[-1], 'x', color='red', markersize=4)
+    ax.text(x[-1], y[-1], f"x0={x0_values[idx]:.1f}", fontsize=8)
+
+st.pyplot(fig)
+
+# Mathematical formulation and notes on main page
+st.markdown("---")
+st.markdown("**Lotka–Volterra system of equations:**")
+st.latex(r"""
+\begin{cases}
+\frac{dx}{dt} = x \left(a - b y\right),\\
+\frac{dy}{dt} = y \left(k b x - m\right),
+\end{cases}
+""")
+
+# Notes
+st.markdown("---")
+st.markdown("""
+**Notes:**  
+- Start point ●, end point ×.  
+- Initial x₀ from 1.0 to 2.0 step 0.1; y₀ = 1.0.  
+- Solver: DOP853, points N = 500.
+""")
+
+# App title at bottom
+st.markdown("---")
+st.markdown("*Lotka–Volterra Model Explorer*")

differential_equations_streamlit_src/requirements.txt

@@ -0,0 +1,5 @@
+streamlit>=1.32
+matplotlib>=3.8
+numpy>=1.26
+scipy
+torch

differential_equations_streamlit_src/utils/__init__.py

@@ -0,0 +1,6 @@
+from .documentation import display_ode_documentation
+from .plain_text_parameters import parameters_to_text, text_to_parameters
+from .compute_metrics import compute_ftle_metrics
+from .highlight_extreme_values_in_table import highlight_extreme_values_in_table
+
+__all__ = ['display_ode_documentation', 'parameters_to_text', 'text_to_parameters', 'compute_ftle_metrics', 'highlight_extreme_values_in_table']

differential_equations_streamlit_src/utils/compute_metrics.py

@@ -0,0 +1,46 @@
+import numpy as np
+from scipy.integrate import solve_ivp
+
+
+def compute_ftle_metrics(rhs, x0, y0, te, t_eval, x, y):
+    """
+    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)
+                # linear fit and r2 diagnostics
+                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 NaN values if computation was unsuccessful
+        return np.nan, np.nan, np.nan
+    except Exception:
+        # Return NaN values in case of exception
+        return np.nan, np.nan, np.nan

differential_equations_streamlit_src/utils/documentation.py

@@ -0,0 +1,43 @@
+import streamlit as st
+
+def display_ode_documentation():
+    """
+    Displays the ODE system documentation and equations in the Streamlit interface.
+    This includes annotations about the curves, metrics, FTLE diagnostics, and the
+    mathematical formulation of the gene regulatory ODE system.
+    """
+    st.markdown("---")
+    st.markdown("- Each curve is annotated with its `idx` at the final point.")
+    st.markdown("- Table shows robust curvature statistics (median, p10, p90) and path length.")
+    st.markdown("- FTLE diagnostics include R^2 of ln(dist) fit (ftle_r2). Anomaly score combines FTLE, path length, max curvature and R^2 reliability.")
+    
+    st.markdown("---")
+    st.markdown("**Column Descriptions:**")
+    st.markdown("- idx - Index of the trajectory, starting from 0")
+    st.markdown("- 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)")
+    st.markdown("- ftle_r2 - Coefficient of determination (R²) of the linear fit for FTLE, indicating reliability of the ftle estimate")
+    st.markdown("- amp - Amplitude (max−min of radial distance sqrt(x²+y²))")
+    st.markdown("- final_dist - Final distance between the original trajectory and its companion trajectory with tiny perturbation")
+    st.markdown("- hurst - Hurst exponent using the rescaled range (R/S) method calculated for x(t) and y(t) and averaged")
+    st.markdown("- curv_rad_mn - Mean curvature radius computed from 1/κ(t) where κ(t) is the curvature")
+    st.markdown("- curv_rad_med - Median curvature radius computed from 1/κ(t) where κ(t) is the curvature")
+    st.markdown("- curv_rad_std - Standard deviation of curvature radius")
+    st.markdown("- curv_p10 - 10th percentile of curvature radius")
+    st.markdown("- curv_p90 - 90th percentile of curvature radius")
+    st.markdown("- curv_ct_fin - Number of finite radius samples")
+    st.markdown("- initial_x - X coordinate of the initial point")
+    st.markdown("- initial_y - Y coordinate of the initial point")
+    st.markdown("- path_len - Total arclength computed as sum of Euclidean distances between consecutive points along the trajectory")
+    st.markdown("- max_kappa - Maximum finite curvature value, useful to detect sharp bends")
+    st.markdown("- 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")
+    st.markdown("- curv_rad_lcl_z - Local z-score of curve median curvature radius relative to nearest neighbors in initial condition space")
+    st.markdown("- 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)")
+
+    st.markdown("---")
+    st.markdown("**System of ODEs (safe):**")
+    st.latex(r"""
+\begin{cases}
+\frac{dx}{dt} = \frac{K\,x^{1/\alpha}}{b^{1/\alpha} + x^{1/\alpha}} - \gamma_1\,x,\\[6pt]
+\frac{dy}{dt} = \frac{K\,y^{1/\alpha}}{b^{1/\alpha} + y^{1/\alpha}} - \gamma_2\,y.
+\end{cases}
+""")

differential_equations_streamlit_src/utils/highlight_extreme_values_in_table.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import numpy as np
+
+
+def highlight_extreme_values_in_table(df):
+    """
+        Applies conditional formatting to highlight extreme values in metrics DataFrame.
+        Highlights top 2 values in chocolate color for columns where high values are significant,
+        and top 2 minimum values in darkturquoise color for columns where low values are significant.
+        Works with both original and shortened column names (e.g., curv_radius_mean → curv_rad_mn).
+        """
+    # Create a copy of the DataFrame with styling
+    styles = pd.DataFrame('', index=df.index, columns=df.columns)
+    
+    # Define possible column names for max values (both original and shortened)
+    max_columns_possible = [
+        ['ftle'], ['ftle_r2'], ['amp'], ['final_dist'], ['hurst'],
+        ['curv_count_finite', 'curv_ct_fin'],  # Both original and shortened
+        ['path_len'], ['max_kappa'], ['frac_high_curv'], ['anomaly_score']
+    ]
+    
+    # Define possible column names for min values (both original and shortened)
+    min_columns_possible = [
+        ['curv_radius_mean', 'curv_rad_mn'],  # Both original and shortened
+        ['curv_radius_median', 'curv_rad_med'],  # Both original and shortened
+        ['curv_radius_std', 'curv_rad_std'],  # Both original and shortened
+        ['curv_radius_local_zscore', 'curv_rad_lcl_z'],  # Both original and shortened
+        ['curv_p10'], ['curv_p90']
+    ]
+    
+    # Identify actual columns in the DataFrame
+    max_columns = []
+    for col_group in max_columns_possible:
+        for col in col_group:
+            if col in df.columns:
+                max_columns.append(col)
+                break  # Only add the first matching column from the group
+    
+    min_columns = []
+    for col_group in min_columns_possible:
+        for col in col_group:
+            if col in df.columns:
+                min_columns.append(col)
+                break  # Only add the first matching column from the group
+    
+    for col in df.columns:
+        if col == 'idx':  # Skip the index column
+            continue
+            
+        if col in max_columns:
+            # Highlight top 2 maximum values in chocolate color
+            if df[col].dtype in ['float64', 'int64', 'float32', 'int32'] and not df[col].isna().all():
+                # Get top 2 values (excluding NaN)
+                valid_values = df[col].dropna()
+                if len(valid_values) >= 2:
+                    top2_values = valid_values.nlargest(2)
+                    styles.loc[valid_values.isin(top2_values), col] = 'background-color: #D2691E'  # chocolate
+                elif len(valid_values) == 1:
+                    top1_idx = valid_values.index[0]
+                    styles.loc[top1_idx, col] = 'background-color: #D2691E'  # chocolate
+         
+        elif col in min_columns:
+            # Highlight top 2 minimum values in darkturquoise color
+            if df[col].dtype in ['float64', 'int64', 'float32', 'int32'] and not df[col].isna().all():
+                # Get top 2 minimum values (excluding NaN)
+                valid_values = df[col].dropna()
+                if len(valid_values) >= 2:
+                    bottom2_values = valid_values.nsmallest(2)
+                    styles.loc[valid_values.isin(bottom2_values), col] = 'background-color: #00CED1'  # darkturquoise
+                elif len(valid_values) == 1:
+                    bottom1_idx = valid_values.index[0]
+                    styles.loc[bottom1_idx, col] = 'background-color: #00CED1'  # darkturquoise
+    
+    return styles

differential_equations_streamlit_src/utils/neural_ode_solver.py

@@ -0,0 +1,105 @@
+# Conditional import for neural ODE solver to handle cases where torch is not available
+try:
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+import numpy as np
+
+
+if TORCH_AVAILABLE:
+    class NeuralODE(nn.Module):
+        """
+        Neural Network surrogate for solving ODEs
+        Takes time t as input and outputs (x(t), y(t))
+        """
+        def __init__(self):
+            super().__init__()
+            self.net = nn.Sequential(
+                nn.Linear(1, 64),
+                nn.Tanh(),
+                nn.Linear(64, 64),
+                nn.Tanh(),
+                nn.Linear(64, 64),
+                nn.Tanh(),
+                nn.Linear(64, 2),  # Output x, y
+            )
+
+        def forward(self, t):
+            return self.net(t)
+
+
+    def train_neural_ode(t_train, x_train, y_train, epochs=2000, lr=1e-3):
+        """
+        Train a neural network to approximate the solution on the training interval
+        
+        Args:
+            t_train: array of time points for training
+            x_train: array of x values for training
+            y_train: array of y values for training
+            epochs: number of training epochs
+            lr: learning rate
+        
+        Returns:
+            Trained model
+        """
+        # Prepare training data
+        t_train_tensor = torch.tensor(t_train[:, None], dtype=torch.float32)
+        xy_train_tensor = torch.tensor(np.column_stack([x_train, y_train]), dtype=torch.float32)
+
+        # Initialize model
+        model = NeuralODE()
+        optimizer = optim.Adam(model.parameters(), lr=lr)
+        loss_fn = nn.MSELoss()
+
+        # Training loop
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            pred = model(t_train_tensor)
+            loss = loss_fn(pred, xy_train_tensor)
+            loss.backward()
+            optimizer.step()
+
+            if epoch % 500 == 0:
+                print(f"Epoch {epoch}, Loss: {loss.item():.6f}")
+
+        return model
+
+
+    def predict_with_neural_ode(model, t_eval):
+        """
+        Predict solution using the trained neural network
+        
+        Args:
+            model: trained NeuralODE model
+            t_eval: array of time points to evaluate
+        
+        Returns:
+            x_pred, y_pred arrays
+        """
+        if model is None:
+            return None, None
+            
+        with torch.no_grad():
+            t_tensor = torch.tensor(t_eval[:, None], dtype=torch.float32)
+            pred = model(t_tensor).numpy()
+            x_pred = pred[:, 0]
+            y_pred = pred[:, 1]
+            
+        return x_pred, y_pred
+else:
+    def train_neural_ode(t_train, x_train, y_train, epochs=2000, lr=1e-3):
+        """
+        Placeholder function when torch is not available
+        """
+        print("PyTorch not available, skipping neural network training")
+        return None
+
+
+    def predict_with_neural_ode(model, t_eval):
+        """
+        Placeholder function when torch is not available
+        """
+        return None, None

differential_equations_streamlit_src/utils/plain_text_parameters.py

@@ -0,0 +1,90 @@
+# plain_text_parameters.py
+# Utility functions to convert parameters <-> plain text
+
+from typing import Dict, Any
+
+# Preferred output order for stable copy/paste strings
+_ORDER = [
+    "t_number",
+    "t_end",
+    "alpha",
+    "K",
+    "b",
+    "gamma1",
+    "gamma2",
+    "initial_radius",
+    "num_points",
+    "circle_start",
+    "circle_end",
+    "center_x",
+    "center_y",
+    "enabled_idx",
+]
+
+
+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)
+
+
+# --- Convert dictionary to plain text ---
+def parameters_to_text(params: Dict[str, Any]) -> str:
+    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)
+
+
+# --- Parse plain text to dictionary ---
+def text_to_parameters(text: str) -> Dict[str, Any]:
+    """
+    Parse strings like "t_number=100; t_end=1.0; alpha=0.001" into a dict.
+    Whitespace and newlines are ignored, both ';' and newlines separate pairs.
+    Values are auto-cast to int where possible, else float, else raw string.
+    """
+    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

gitingest.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+# run from repository root folder
+gitingest . \
+  --include-pattern "*.py" \
+  --include-pattern "README.md" \
+  --include-pattern "requirements.txt" \
+  --exclude-pattern "LICENSE" \
+  --exclude-pattern "*/__pycache__/*" \
+  --output out_gitingest/differ_hug_01.txt