Finite Time Convergence via Nonlinear Sliding Manifolds

43 concepts33 papers1 proposal

In classical control theory, tracking errors are typically designed to decay exponentially. While exponential stability ensures that a system will safely return to equilibrium, it suffers from a fundamental mathematical limitation: the error only approaches zero asymptotically, requiring an infinite time horizon to fully disappear.

For high-performance, safety-critical systems—such as individual-wheel-drive vehicles (Song et al.), robotic manipulators (Zhang et al.), and aerospace vehicles (Yuankai Li et al.)—waiting an infinite amount of time for error elimination is unacceptable. Terminal Sliding Mode Control (TSMC) solves this problem by reshaping the geometry of the sliding surface, forcing tracking errors to hit exactly zero within a guaranteed, finite timeframe.

The Core Mechanism: Why Nonlinear Surfaces Accelerate Convergence

To understand why TSMC works, we must contrast it with traditional Sliding Mode Control (SMC). A conventional sliding surface is linear, typically structured as:

$$s = \dot{e} + c e = 0$$

When the system state is forced onto this surface, the error dynamics follow $\dot{e} = -c e$. The rate of decay is directly proportional to the size of the error. As the error $e$ shrinks close to zero, the speed of convergence ($\dot{e}$) slows to a crawl.

TSMC breaks this bottleneck by introducing a fractional power into the sliding manifold equation:

$$s = \dot{e} + \beta e^{p/q} = 0$$

Here, $p$ and $q$ are positive odd integers chosen such that $0 < p/q < 1$ (for example, $1/3$ or $3/5$). When the system is trapped on this nonlinear surface, its behavior is governed by the differential equation:

$$\dot{e} = -\beta e^{p/q}$$

This subtle algebraic shift completely alters the convergence behavior near the origin. When the tracking error is large ($e > 1$), the fractional power actually provides less restoration force than a linear term. However, as the system approaches its target and the error becomes tiny ($e \to 0$), the fractional power $e^{p/q}$ becomes significantly larger than a linear $e^1$ term.

For instance, if the remaining error is $0.001$ and $p/q = 1/3$, a linear controller's restoration speed is proportional to $0.001$, whereas the TSMC restoration speed is proportional to $0.001^{1/3} = 0.1$. Because the velocity of convergence remains high even as the error vanishes, the system is aggressively pulled to the origin, achieving true zero-error tracking in finite time (Heyan Huang et al.; Chao Chen et al.).

The Singularity Trap and Non-Singular Solutions

While standard TSMC guarantees rapid convergence, it introduces a dangerous mathematical vulnerability known as the singularity problem.

To calculate the control input required to keep the system on the sliding surface, a controller must compute the time derivative of the sliding variable ($\dot{s}$). Differentiating the standard TSMC surface yields:

$$\dot{s} = \ddot{e} + \beta \frac{p}{q} e^{(p/q)-1} \dot{e}$$

Because $p/q < 1$, the exponent $(p/q)-1$ is negative. This transforms the term into a fraction where the error sits in the denominator:

$$\dot{s} = \ddot{e} + \beta \frac{p}{q} \frac{\dot{e}}{e^{1 - p/q}}$$

As the tracking error $e$ approaches zero while its derivative $\dot{e}$ is non-zero, the controller is forced to divide by zero. The required control effort spikes toward infinity, causing physical actuators to saturate, vibrate violently, or fail entirely (Shi et al.).

To circumvent this failure mode, researchers developed Non-singular Terminal Sliding Mode Control (NTSMC). As explained by Yongchun Liu and Deng et al., the trick is to shift the fractional power from the error state to its derivative:

$$s = e + \beta \dot{e}^{p/q} = 0$$

where the ratio is inverted such that $1 < p/q < 2$. When we differentiate this new surface, the derivative becomes:

$$\dot{s} = \dot{e} + \beta \frac{p}{q} \dot{e}^{(p/q)-1} \ddot{e}$$

Because $p/q > 1$, the exponent $(p/q)-1$ remains positive. The term stays safely in the numerator, completely eliminating the risk of infinite control spikes while preserving the finite-time convergence property. Other variations, such as those proposed by Guo et al., utilize specialized polynomial structures to achieve the same singularity-free, bounded control behavior as errors vanish.

Optimizing the Journey: Fast and Fixed-Time Control

Because standard TSMC performs poorly when initial errors are large, researchers frequently deploy Fast Terminal Sliding Mode Control (FTSMC). This architecture combines both linear and nonlinear error terms on a single surface:

$$s = \dot{e} + \alpha e + \beta e^{p/q} = 0$$

As demonstrated by Yifan Liu et al. and Yuren Li et al., this hybrid design offers the best of both worlds. When the system is far from its target, the linear term $\alpha e$ dominates, driving fast exponential convergence. Once the error shrinks below a certain threshold, the nonlinear term $\beta e^{p/q}$ takes over, snapping the error to zero.

   Error (e)
     ^
     |   /\  <- Initial Disturbance
     |  /  \
     | /    \   <- Linear term dominates (Fast exponential decay)
     |/      \
     |        \
     |         \  <- Nonlinear term takes over (Aggressive terminal pull)
     +----------------------------------------> Time (t)
               |<- Finite Settling Time ->|

However, even with FTSMC, the total settling time remains dependent on the system's initial states (Chao Chen et al.). If a system experiences an unexpectedly massive initial disturbance, the time required to reach equilibrium will scale accordingly.

To decouple performance from initial conditions, the field has transitioned toward Fixed-Time Sliding Mode Control. By structuring the sliding surface with multiple complementary fractional powers, controllers designed by Sun et al. guarantee that the system will settle within a strict, user-defined time window, regardless of how far away from equilibrium the system starts.

Mitigating Chattering with Advanced Reaching Laws

A historical drawback of any sliding mode approach is "chattering"—high-frequency physical oscillations caused by the discontinuous switching functions (like the signum function) used to force system states onto the sliding surface (Rodrigues et al.).

To achieve smooth actuation without sacrificing finite-time performance, modern implementations pair terminal sliding surfaces with advanced reaching laws and observers. For instance, Huang and He et al. leverage the super-twisting algorithm, a second-order sliding mode technique that effectively hides the discontinuous switching behind an integral operator, yielding a continuous, chattering-free control signal. When combined with integral feedback mechanisms (Hu et al.) or power reaching laws (Zhou), the system state is driven rapidly to the sliding manifold and guided smoothly to the origin without damaging physical hardware.

Key Foundational Work

A terminal sliding mode based torque distribution control for an individual-wheel-drive vehicle (2014) — contributed 2 concept elements to this direction.
Note on Minimax Sliding Mode Control Design for Linear Systems (2017) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_terminal_sliding_mode_control_e7bf3825,
  title = {terminal sliding mode control},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/terminal-sliding-mode-control/rdr_e7bf3825a6af45d0b2d908213e2db592},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_terminal_sliding_mode_control_e7bf3825_v1,
  title = {terminal sliding mode control},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/terminal-sliding-mode-control/rdr_e7bf3825a6af45d0b2d908213e2db592/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake