ARGOSc: Sparse Regression with Control

• ARGOSc is a controlled-system discovery framework that extends ARGOS to identify differential equations with external forcing by incorporating control inputs in its regression library.
• It automates key steps such as Savitzky–Golay smoothing, adaptive LASSO, dictionary trimming with BIC selection, and bootstrap-based uncertainty quantification.
• Empirical results show ARGOSc outperforms methods like SINDYc in robustness and accuracy across benchmark systems including Van der Pol, Lotka–Volterra, and Lorenz.

Searching arXiv for recent and directly relevant work on ARGOSc and its parent ARGOS framework. Search query: "Automatic Regression for Governing Equations with Control ARGOSc ARGOS sparse regression governing equations"

ARGOS with Control (ARGOSc) is a sparse-regression framework for discovering governing equations of dynamical systems in the presence of exogenous inputs, control actions, or forcing. It extends the Automatic Regression for Governing Equations (ARGOS) pipeline from autonomous systems of the form $\dot{x}(t)=f(x(t))$ to controlled systems of the form $\dot{x}(t)=f(x(t),u(t))$, while retaining the same core stages: Savitzky–Golay smoothing, numerical differentiation, adaptive LASSO, dictionary trimming, threshold selection via BIC, and bootstrap-based uncertainty quantification (Javadi et al., 11 Sep 2025). In this formulation, the principal structural change is that the regression library becomes a joint function of states and inputs, $\Theta(X,U)$, so that ARGOSc can identify how forcing enters the dynamics and separate driven behavior from intrinsic dynamics, to the extent allowed by the data and chosen library (Javadi et al., 11 Sep 2025).

1. Origins and conceptual scope

ARGOSc is explicitly presented as an extension of ARGOS, the latter being a sparse-regression-based pipeline for discovering ordinary differential equations from time-series data of an unforced system (Javadi et al., 11 Sep 2025). In the original ARGOS setting, the target class is

$\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$

Given sampled states $X\in\mathbb{R}^{n\times m}$ at times $t_1,\dots,t_n$, ARGOS denoises each state time series with a Savitzky–Golay filter, computes derivatives $\dot{X}$ from the smoothed signal, builds a dictionary $\Theta(X)$ of candidate basis functions, performs sparse regression with LASSO or adaptive LASSO, trims and refits the dictionary using thresholding, OLS, and BIC, and then quantifies uncertainty via bootstrap, retaining only terms with nonzero $95\%$ bootstrap confidence intervals (Javadi et al., 11 Sep 2025).

ARGOSc generalizes this architecture to systems with control: $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$ or, vectorially,

$\dot{x}(t)=f(x(t),u(t))$0

possibly with noise,

$\dot{x}(t)=f(x(t),u(t))$1

The conceptual emphasis is not a change in identification philosophy but an expansion of the hypothesis class: ARGOSc treats control and forcing as first-class explanatory variables in the governing equations, rather than as unmodeled disturbances (Javadi et al., 11 Sep 2025).

This framing places ARGOSc in direct relation to sparse system identification with control, especially SINDYc. The data indicate that ARGOSc shares the basic sparse-regression spirit of SINDYc but differs in its more automated model-selection pipeline, explicit uncertainty quantification, and stronger emphasis on robustness to low- to medium-noise data (Javadi et al., 11 Sep 2025). A plausible implication is that ARGOSc is best understood not as a departure from the sparse-identification paradigm but as a more statistically elaborate extension of ARGOS to forced systems.

2. Mathematical formulation

ARGOSc assumes observations from a forced dynamical system

$\dot{x}(t)=f(x(t),u(t))$2

with state vector $\dot{x}(t)=f(x(t),u(t))$3, control/input vector $\dot{x}(t)=f(x(t),u(t))$4, and unknown smooth functions $\dot{x}(t)=f(x(t),u(t))$5 (Javadi et al., 11 Sep 2025). From time samples $\dot{x}(t)=f(x(t),u(t))$6, one constructs

• $\dot{x}(t)=f(x(t),u(t))$7 with rows $\dot{x}(t)=f(x(t),u(t))$8,
• $\dot{x}(t)=f(x(t),u(t))$9 with rows $\Theta(X,U)$0,
• $\Theta(X,U)$1 from numerically estimated derivatives.

The central structural object is the dictionary

$\Theta(X,U)$2

whose columns are candidate basis functions involving both $\Theta(X,U)$3 and $\Theta(X,U)$4: $\Theta(X,U)$5 Here, $\Theta(X,U)$6 is the constant term, $\Theta(X,U)$7 denotes all monomials of total degree $\Theta(X,U)$8 in the state variables, $\Theta(X,U)$9 denotes monomials of degree $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$0 in the inputs, and $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$1 denotes optional additional nonlinear functions such as trigonometric terms or other customized features based on prior knowledge (Javadi et al., 11 Sep 2025). Cross terms such as $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$2 and $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$3 are included as part of the combined polynomial library or customized $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$4 (Javadi et al., 11 Sep 2025).

The regression model is

$\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$5

with $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$6 the coefficient matrix and $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$7 the residual matrix. For each state component,

$\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$8

ARGOSc estimates $\dot{x}(t) = f(x(t)), \qquad x(t)\in\mathbb{R}^m.$9 via an $X\in\mathbb{R}^{n\times m}$0-penalized least-squares problem: $X\in\mathbb{R}^{n\times m}$1 where $X\in\mathbb{R}^{n\times m}$2 is chosen by $X\in\mathbb{R}^{n\times m}$3-fold cross-validation and $X\in\mathbb{R}^{n\times m}$4 are weights, with adaptive LASSO weights derived from ridge regression coefficients (Javadi et al., 11 Sep 2025).

The article on ARGOSc states that “automatic” refers to four layers of automation: automatic penalty selection by cross-validation, automatic dictionary trimming, automatic threshold selection by sweeping coefficient thresholds $X\in\mathbb{R}^{n\times m}$5 and choosing the minimum-BIC model, and automatic term validation via bootstrapped confidence intervals (Javadi et al., 11 Sep 2025). This makes the method comparatively hands-off once a generic library has been specified.

3. Algorithmic pipeline

The ARGOSc algorithm is presented as a direct modification of the ARGOS supplementary procedure by adding $X\in\mathbb{R}^{n\times m}$6 to the dictionary (Javadi et al., 11 Sep 2025). The inputs are smoothed state data $X\in\mathbb{R}^{n\times m}$7, input data $X\in\mathbb{R}^{n\times m}$8, numerical derivatives $X\in\mathbb{R}^{n\times m}$9, polynomial degree $t_1,\dots,t_n$0, and significance level $t_1,\dots,t_n$1 for confidence intervals (Javadi et al., 11 Sep 2025).

The first step is the construction of an initial design matrix. The algorithm computes an initial design dimension

$t_1,\dots,t_n$2

which counts monomials in the states; in practice, the dictionary also includes input terms and any custom functions (Javadi et al., 11 Sep 2025). One then constructs

$t_1,\dots,t_n$3

using all monomials up to degree $t_1,\dots,t_n$4 in the columns of $t_1,\dots,t_n$5 and $t_1,\dots,t_n$6, together with any additional customized features $t_1,\dots,t_n$7 (Javadi et al., 11 Sep 2025).

The second step is dictionary trimming through sparse regression. One chooses either LASSO or adaptive LASSO, selects $t_1,\dots,t_n$8 by $t_1,\dots,t_n$9-fold cross-validation, and solves a first penalized regression on $\dot{X}$0 (Javadi et al., 11 Sep 2025). The highest polynomial order among variables with nonzero coefficients is denoted $\dot{X}$1, and the library is then trimmed to retain only columns up to degree $\dot{X}$2 and any corresponding custom functions (Javadi et al., 11 Sep 2025).

The third step is final point estimation and model selection. Sparse regression is rerun on the trimmed dictionary $\dot{X}$3, after which a threshold grid

$\dot{X}$4

is swept (Javadi et al., 11 Sep 2025). For each threshold, the active set is selected, OLS is performed on the retained columns, and the Bayesian Information Criterion is computed. The model with minimum BIC is selected, and the final point estimate is the corresponding OLS estimate (Javadi et al., 11 Sep 2025).

The fourth step is bootstrap-based uncertainty quantification. The method uses $\dot{X}$5 bootstrap samples, repeats the earlier steps, and constructs empirical confidence intervals for each coefficient (Javadi et al., 11 Sep 2025). A term is retained only if its $\dot{X}$6 bootstrap confidence interval does not contain zero. This provides the final sparse model.

A concise summary is useful here.

Stage	Operation	Purpose
Smoothing and differentiation	Savitzky–Golay filtering and derivative estimation	Noise reduction before regression
Initial regression	Adaptive LASSO on $\dot{X}$7	Preliminary sparsity pattern
Trimming and BIC selection	Threshold sweep, OLS refit, BIC minimization	Parsimonious model selection
Bootstrap validation	$\dot{X}$8 resamples, $\dot{X}$9 confidence intervals	Term stability and uncertainty screening

The article emphasizes that ARGOSc “implements exactly this pipeline but with $\Theta(X)$0 instead of $\Theta(X)$1” (Javadi et al., 11 Sep 2025). This is important because it clarifies that the contribution lies in controlled-system identification within a pre-existing automated sparse-regression framework, not in a wholly new optimization pipeline.

4. Noise handling, robustness, and comparison with SINDYc

ARGOSc is described as being designed with noise robustness in mind (Javadi et al., 11 Sep 2025). The first defense against noise is Savitzky–Golay filtering, which smooths the raw time series and reduces the amplification of noise during derivative estimation. The second is the $\Theta(X)$2 regularization of LASSO or adaptive LASSO, which suppresses small noise-driven coefficients. The third is dictionary trimming, which removes higher-order terms that appear only weakly supported. The fourth is thresholding with BIC, which rejects small terms that marginally improve mean-squared error but are not justified by model complexity. The fifth is bootstrap confidence-interval screening, which discards unstable coefficients whose empirical intervals include zero (Javadi et al., 11 Sep 2025).

The paper does not provide formal recovery guarantees or sample-complexity bounds. Instead, it states that the work “does not present new formal theoretical results” and relies on the known oracle properties of adaptive LASSO together with empirical demonstrations (Javadi et al., 11 Sep 2025). This suggests that ARGOSc should be viewed as an empirically validated procedure rather than a theorem-driven identification method.

The principal methodological comparison is to SINDYc. According to the data, the main differences are these: SINDYc typically relies on raw data or simple smoothing and finite differences, its sparse regression often uses sequential thresholded least squares or manually tuned thresholds, and it generally lacks built-in uncertainty quantification and formal model selection. ARGOSc, by contrast, uses Savitzky–Golay smoothing, adaptive LASSO with cross-validated $\Theta(X)$3, a threshold sweep selected by BIC, and bootstrap confidence intervals (Javadi et al., 11 Sep 2025). The result is presented as a more statistically principled and less manually tuned pipeline.

The quantitative comparisons reported in the source are strong. On the Van der Pol oscillator at SNR $\Theta(X)$4 dB, SINDYc yields test MSEs of $\Theta(X)$5 and $\Theta(X)$6 with $\Theta(X)$7 and $\Theta(X)$8 for the two state variables, whereas ARGOSc yields $\Theta(X)$9 and $95\%$0 with $95\%$1 and $95\%$2 (Javadi et al., 11 Sep 2025). On Lotka–Volterra with sinusoidal forcing at SNR $95\%$3 dB, SINDYc gives negative $95\%$4 values, while ARGOSc attains $95\%$5 and $95\%$6 (Javadi et al., 11 Sep 2025). On the forced Lorenz system, SINDYc again produces negative $95\%$7 values at the tested noise levels, while ARGOSc reports MSEs around $95\%$8–$95\%$9 and $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$0 for all states (Javadi et al., 11 Sep 2025).

A plausible implication is that ARGOSc’s practical advantage comes less from a fundamentally different sparse model class than from a more robust end-to-end procedure for smoothing, selecting, validating, and pruning candidate terms under noisy controlled dynamics.

5. Benchmark systems and empirical behavior

The paper evaluates ARGOSc on three benchmark systems with control or forcing: a Van der Pol oscillator with feedback control, a Lotka–Volterra predator–prey model with sinusoidal forcing, and a Lorenz system with periodic forcing (Javadi et al., 11 Sep 2025).

For the Van der Pol case, the true system is

$\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$1

with $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$2, $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$3, and $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$4 (Javadi et al., 11 Sep 2025). Data are generated over $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$5 s with timestep $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$6 s, giving $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$7 samples, with the first $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$8 s used for training and the remaining $\dot{x}_j(t) = f_j(x(t),u(t)), \quad j=1,\dots,m,$9 s for validation (Javadi et al., 11 Sep 2025). The results indicate that both ARGOSc and SINDYc can roughly reproduce the dynamics at moderate noise, but ARGOSc is substantially more accurate. At the same time, the source notes that both methods have difficulty disentangling intrinsic dynamics from the feedback control law because $\dot{x}(t)=f(x(t),u(t))$00 is a linear function of the states and therefore strongly collinear with state terms (Javadi et al., 11 Sep 2025). This is explicitly described as an identifiability issue.

For Lotka–Volterra with forcing, the system is

$\dot{x}(t)=f(x(t),u(t))$01

with $\dot{x}(t)=f(x(t),u(t))$02, $\dot{x}(t)=f(x(t),u(t))$03, $\dot{x}(t)=f(x(t),u(t))$04, $\dot{x}(t)=f(x(t),u(t))$05, and $\dot{x}(t)=f(x(t),u(t))$06 (Javadi et al., 11 Sep 2025). The paper states that ARGOSc accurately captures all trajectories during testing, with $\dot{x}(t)=f(x(t),u(t))$07 at both tested noise levels, while SINDYc captures only the first one or two cycles before its amplitudes and phases diverge (Javadi et al., 11 Sep 2025).

For the forced Lorenz system,

$\dot{x}(t)=f(x(t),u(t))$08

with $\dot{x}(t)=f(x(t),u(t))$09, $\dot{x}(t)=f(x(t),u(t))$10, $\dot{x}(t)=f(x(t),u(t))$11, and $\dot{x}(t)=f(x(t),u(t))$12 (Javadi et al., 11 Sep 2025). The data indicate that ARGOSc tracks the chaotic attractor over the full test window, whereas SINDYc tracks the system only for a few seconds before diverging strongly (Javadi et al., 11 Sep 2025). The same section also reports that naive ARGOS, when run without including $\dot{x}(t)=f(x(t),u(t))$13 in the library, produces an unstable model that fails to reproduce the test trajectories (Javadi et al., 11 Sep 2025). This underscores the central claim that explicit modeling of forcing is essential for controlled systems.

6. Assumptions, limitations, and practical use

The paper states two explicit assumptions. First, the true governing equations must be sparse in the chosen library. Second, the true governing terms must actually be present in $\dot{x}(t)=f(x(t),u(t))$14 (Javadi et al., 11 Sep 2025). If either assumption fails, ARGOSc can only recover the best approximation available in the supplied basis. The source is explicit that if a key functional form is missing, no sparse-regression method can recover the correct model (Javadi et al., 11 Sep 2025).

Several limitations are also identified. ARGOSc is demonstrated only under low- to medium-noise conditions; very high noise may render derivative estimation and sparse identification unreliable (Javadi et al., 11 Sep 2025). If the control input lacks richness, is too simple, or is highly correlated with the states, it becomes difficult to distinguish input effects from intrinsic dynamics; this is highlighted in the Van der Pol feedback example (Javadi et al., 11 Sep 2025). The method also imposes a heavier computational burden than SINDYc because it combines cross-validated adaptive LASSO, threshold grid search with OLS and BIC, and $\dot{x}(t)=f(x(t),u(t))$15 bootstrap resamples (Javadi et al., 11 Sep 2025). Finally, the reported experiments concern systems up to three dimensions with scalar forcing, and extending to higher-dimensional systems with multiple inputs may require more sophisticated library design and regularization (Javadi et al., 11 Sep 2025).

The implementation guidance in the source is practical. It recommends starting with polynomial terms in $\dot{x}(t)=f(x(t),u(t))$16 and $\dot{x}(t)=f(x(t),u(t))$17 up to modest order, for example $\dot{x}(t)=f(x(t),u(t))$18–$\dot{x}(t)=f(x(t),u(t))$19, including cross terms (Javadi et al., 11 Sep 2025). If the system is suspected to involve special functions such as sinusoids, those should be included in $\dot{x}(t)=f(x(t),u(t))$20 (Javadi et al., 11 Sep 2025). Sampling should be sufficiently fast to resolve the system dynamics; in the reported experiments, $\dot{x}(t)=f(x(t),u(t))$21 s and $\dot{x}(t)=f(x(t),u(t))$22 training samples were used (Javadi et al., 11 Sep 2025). The paper also notes that complexity grows with the number of states, number of inputs, polynomial degree, number of custom basis functions, and bootstrap samples (Javadi et al., 11 Sep 2025).

This suggests a practical characterization of ARGOSc: it is a controlled-system identification framework that is comparatively robust and automated for small to moderate systems, provided that the library is sufficiently expressive and the input signal is informative enough to separate forcing from autonomous dynamics.

7. Significance and relation to the broader ARGOS lineage

ARGOSc is significant because it extends ARGOS from autonomous to forced systems without abandoning interpretability. The discovered model remains an explicit differential equation whose right-hand side is a sparse linear combination of dictionary functions (Javadi et al., 11 Sep 2025). This means the final output is not merely predictive but also structural: it identifies which terms, including control-dependent ones, are active in the dynamics.

The source explicitly argues that most real-world systems operate under control actions or external forcing, and that ignoring inputs can yield incorrect dynamics (Javadi et al., 11 Sep 2025). In that sense, ARGOSc expands the applicability of the ARGOS program from autonomous benchmark discovery to settings relevant to predictive control, robotics, engineering, and other cyber-physical domains. Its contribution is therefore methodological rather than domain-specific: it preserves the interpretability and automated model-selection apparatus of ARGOS while making the discovered equations responsive to external inputs.

Within the broader sparse-identification literature, ARGOSc is positioned closest to SINDYc, but the paper’s emphasis is on stronger automation, more explicit uncertainty handling, and better empirical performance under noisy conditions (Javadi et al., 11 Sep 2025). A plausible implication is that ARGOSc will be most attractive where the objective is not only to fit a controlled dynamical model but also to obtain a parsimonious and statistically screened governing equation with minimal manual threshold tuning.

In summary, ARGOSc designates a particular synthesis: sparse governing-equation discovery, explicit control-aware libraries, automated model selection through cross-validation and BIC, and bootstrap-based term validation. Its empirical demonstrations on Van der Pol, Lotka–Volterra, and Lorenz systems suggest that this synthesis is especially effective when forcing terms must be inferred under noise and when standard sparse-control baselines degrade.