⚡ electrical engineering

Tracking Through Decoupling Singularities: A Singularity-Robust Homotopy-Continuation Extension of Feedback Linearization

This paper proposes a singularity-robust trajectory-tracking controller for square nonlinear systems that overcomes decoupling singularities by recasting the problem as a real-time arc-length homotopy continuation, thereby enabling bounded control and continuous tracking through points where traditional feedback linearization fails.

Original authors: Alex Borisevich

Published 2026-07-14

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Alex Borisevich

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are driving a high-tech robot car that needs to follow a winding road perfectly. Usually, the car's computer uses a super-smart map (called feedback linearization) to calculate exactly how much to turn the wheels to stay on the path. It's like having a GPS that tells you, "Turn left 30 degrees right now," and the car does it perfectly.

But sometimes, the road hits a weird spot—a singularity. Maybe it's a sharp hairpin turn where the map says, "To follow this line, you need to turn the wheels infinitely fast!" or "The road disappears for a split second!" In the real world, your car can't spin its wheels infinitely fast; it would just break, stall, or fly off the road. For decades, when robots hit these spots, they would either crash, stop, or have to switch to a completely different, clumsy backup plan.

This paper introduces a new way to drive through these "impossible" spots without crashing, without switching plans, and without the wheels spinning out of control. The authors call it a Singularity-Robust Homotopy-Continuation Extension. That's a mouthful, so let's break it down with a story.

The Problem: The Infinite Turn

Think of the robot's map as a mathematical equation. When the robot hits a singularity, the equation tries to divide by zero. In math, that's a disaster. In the robot, it means the command to turn the wheels becomes a number so huge it's basically infinity. The paper shows that if you try to use the old "perfect map" method near these spots, the control signal explodes.

The Solution: The "Detour" Trick

The authors' big idea is to stop trying to solve the impossible equation directly. Instead, they add a secret extra dimension to the problem.

Imagine you are trying to walk through a wall. You can't go through it, and you can't go around it easily. But what if you could temporarily step into a parallel universe where the wall doesn't exist, walk past the spot where the wall was, and then step back into our world?

That's what this method does. It takes the robot's current position and the target destination and adds a "homotopy direction" (let's call it a magic detour vector).

The Augmented Map: Instead of just looking at the road, the computer builds a bigger, 3D map that includes this magic detour.
The Least-Norm Solution: When the robot hits the "infinite turn" spot, the computer doesn't try to force the impossible turn. Instead, it asks: "What is the smallest, most reasonable move we can make that keeps us on track?" It uses a mathematical tool called the Moore–Penrose solution (think of it as the "most polite" way to solve a broken puzzle) to find a path that stays bounded.
The Result: The robot glides through the singularity with a bounded (safe, finite) control signal. It doesn't go infinite; it just takes a tiny, smooth detour and snaps back to the road immediately after.

The Two Ways to Cross: Reflection vs. Branch Crossing

Here is where it gets really cool. When the robot hits a "fold" in the road (a spot where the path doubles back on itself, like a U-turn), the method has to make a choice. The paper proves there are exactly two ways to handle this, and the choice depends on how you set the "detour" direction:

The Reflection (The Bounce): If the road ahead is blocked (like a dead end), the robot hits the singularity, slides along the edge for a moment, and then bounces back the way it came. It's like a ball hitting a wall and rolling back. The paper shows this is a stable, safe behavior where the robot stays on the same "branch" of the solution.
The Crossing (The Flip): If the road continues on the other side (like a bridge over a canyon), the robot can choose to flip to the other side of the fold. It crosses the singularity and continues on a completely different path. The paper shows this is possible, but it requires a very specific setup. If you try to cross when you shouldn't, the robot might get "unlocked" and lose its grip on the path for a split second before re-locking.

The authors ran simulations to prove this works. They tested it on:

A 2-DOF robotic arm (a simple robot with two joints). When the arm stretched out to its maximum reach (a singularity), the old method demanded the joints spin at 22 million radians per second (which is impossible). The new method kept the speed under 3 radians per second and smoothly bounced back or crossed over, depending on the settings.
A power converter (a device that changes electricity voltage). This device has two types of "impossible" spots: one where it switches modes (buck/boost) and one where it hits resonance. The new controller handled both, keeping the control signals bounded while the old method demanded signals that were 100,000 times larger.

What This Does NOT Do (The Rules)

It is important to know what this paper doesn't claim.

It doesn't fix broken robots: If the robot's internal dynamics are unstable (like a car with a broken engine that will catch fire if you drive it), this method won't save it. The paper explicitly states it requires the system to be "minimum phase" (stable on the inside) to work.
It doesn't create new powers: It doesn't make the robot stronger or faster. It just prevents it from crashing when the math gets weird.
It's not a magic wand for everything: The paper proves this works for "square" systems (where the number of controls equals the number of outputs) and for systems with a specific "relative degree" (how many steps it takes for a control to affect the output). It doesn't claim to solve every type of robot problem in the universe.

How Sure Are They?

The authors are very confident in the math. They have proved theorems showing that:

The control signal will never go to infinity (it stays bounded).
The robot will track the path with a tiny error (proportional to $1/k$ , where $k$ is a gain you set).
After crossing the singularity, the robot will "re-lock" to the path and track perfectly again.

They also simulated these results on computers. In the simulations, the new method worked exactly as the math predicted. The old method failed spectacularly (demanding infinite or massive control signals), while the new method stayed calm and bounded.

The Bottom Line

This paper is like inventing a new steering system for a robot that knows how to handle "dead ends" in the math. Instead of crashing when the map breaks, the robot takes a tiny, calculated detour, glides through the impossible spot, and snaps back to the road. It's a robust, safe way to keep robots moving even when the math says they should stop. The authors suggest that while this doesn't fix every problem, it solves a very specific, annoying class of crashes that have plagued engineers for a long time.

Technical Summary: Tracking Through Decoupling Singularities via Homotopy Continuation

1. Problem Statement

Input–output feedback linearization is a standard technique for tracking control in nonlinear systems with a well-defined relative degree. However, this method fails at decoupling singularities, defined as the locus where the decoupling matrix $\Lambda(x)$ loses rank (i.e., $\det \Lambda(x) = 0$ ). At these points, the relative degree is lost, the linearizing control law $u = \Lambda^{-1}(v - a)$ becomes unbounded, and trajectory tracking is typically impossible without switching strategies or approximations.

Existing approaches, such as damped least squares (DLS), trade tracking accuracy for boundedness near singularities but introduce errors in regular regions and lack a rigorous criterion for whether a specific singularity can be crossed. Other methods rely on pre-planned trajectories or dynamic reciprocity conditions for specific mechanical systems (e.g., Type-2 parallel mechanisms) but do not offer a general, unified framework for arbitrary square control-affine systems.

This paper addresses the problem of tracking a reference trajectory through isolated decoupling singularities with bounded control effort, without requiring case analysis or switching between different control laws.

2. Methodology

The proposed method recasts the trajectory tracking problem as a real-time arc-length homotopy continuation. Instead of directly inverting the decoupling matrix $\Lambda(x)$ , the controller embeds the tracking problem into a one-parameter family of equations and solves for the state velocity and a homotopy parameter simultaneously.

Core Mechanism

Augmented Jacobian: The method replaces the singular decoupling matrix $\Lambda(x)$ with an augmented matrix $A = [\Lambda(x) \mid b]$ , where $b$ is a homotopy direction vector defined as $b(t) = h(x_0) - y^*(t)$ (the difference between the anchor state and the reference).
Least-Norm Solution: The control input $u$ and the rate of the homotopy parameter $\dot{\mu}$ are computed as the least-norm (Moore–Penrose) solution to the linear system:
$A \begin{bmatrix} u \\ \dot{\mu} \end{bmatrix} = -B$
where $B$ represents the drift and reference tracking error terms.
Transversality Condition: The method relies on a transversality condition: $w^T b \neq 0$ , where $w$ is a vector in the left null space of $\Lambda(x)$ . This condition ensures that the homotopy direction $b$ has a non-zero component along the uncontrollable mode, allowing the augmented matrix $A$ to maintain full row rank even when $\Lambda(x)$ drops rank by one.
Orientation and Behavior: The controller includes a scalar gain $k$ $k$ and a locking error $e = t - \mu$ $e = t - μ$ . The behavior at a singularity (specifically a Whitney fold) is determined by the orientation of the kernel vector $\hat{n}$ $\overset{n}{^}$ of $A$ $A$ :
- Reflection ( $\rho \geq 0$ ): The controller keeps the homotopy parameter monotonic. At a fold, the state "slides" along the singular set and reflects back to the incoming branch. This is the default, stable behavior.
- Crossing (Continuity): The controller maintains the continuous tangent direction of the solution curve. This allows the state to cross the singularity to the opposite branch, though this may result in larger transients and a temporary loss of parameter locking.

Extensions

Dynamic Systems: For dynamic control-affine systems, the method applies directly to the decoupling matrix $\Lambda(x) = Dh(x)g(x)$ . Boundedness of the full state is guaranteed if the system is minimum phase (internal zero dynamics are stable).
Arbitrary Relative Degree: For systems with relative degree $r > 1$ , the method uses a filtered-error reduction. A filtered tracking error $\sigma$ is defined such that the system appears to have relative degree one, allowing the same augmentation strategy to be applied.

3. Key Contributions

The paper makes five primary theoretical and practical contributions:

Kernel Structure Lemma: A rigorous characterization of when the augmentation repairs a rank drop. It proves that if the transversality condition holds, the augmented matrix $A$ remains full rank, but the "feedback authority" (the component of the kernel vector corresponding to the homotopy parameter) collapses to zero exactly at the singularity.
Bounded Crossing Theorem: A proof that under the transversality condition, the controller produces bounded control inputs, the tracking error remains bounded during the crossing (with a transient excursion proportional to the time spent near the singularity), and the system re-locks to the reference exponentially after crossing.
Reflection vs. Crossing Dichotomy: A resolution of the behavior at generic folds. The paper proves that the choice of kernel orientation dictates whether the system reflects (slides and returns) or crosses (passes to the other branch). The reflection case is shown to be a Filippov sliding mode, while crossing corresponds to traversing the $Z/2$ monodromy of the fold cover.
Generalization to Higher Relative Degrees: The extension of the method to arbitrary relative degrees via filtered-error reduction, proving that the boundedness and re-locking properties hold for these systems as well.
Consistency with Feedback Linearization: A proof that away from singularities, the controller is identical to exact input–output feedback linearization up to an $O(1/k)$ error term, ensuring no accuracy penalty in regular operating regions.

4. Simulation Results and Validation

The theory is validated through numerical simulations on four distinct systems:

Scalar Cubic System: A simple 1-DOF system with a cubic output map. The controller successfully tracks a reference that sweeps through two decoupling singularities, maintaining bounded control where the naive inverse diverges by orders of magnitude ( $10^4$ ).
2-DOF Planar Robotic Arm: The controller tracks a circular trajectory that forces the arm to full extension (a kinematic singularity).
- With the reflection orientation, the arm reaches the singularity, slides along the boundary, and returns, with joint velocities remaining bounded ( $<3$ rad/s) compared to the naive resolved-rate demand ( $\sim 10^7$ rad/s).
- With the crossing orientation, the arm successfully flips its elbow configuration ( $q_2$ from positive to negative), demonstrating the ability to change working modes, albeit with larger transients.
Dynamic Relative-Degree-One and Two Plants: Simulations on dynamic systems confirm that the method handles control singularities while keeping internal states bounded (due to the minimum-phase assumption). The controller passes through singularities with bounded effort, whereas feedback linearization diverges.
Dual-Active-Bridge (DAB) Series Resonant Converter: An application to power electronics where the steady-state characteristic is treated as the output map. The controller handles two distinct singularities:
- Buck/Boost Fold: A transversal crossing where the modulation parameter passes through a mode transition.
- Resonance Singularity: A reflection at the resonant frequency where the power gain is maximized. The controller naturally reflects at the resonance peak, preserving zero-voltage switching (ZVS) and avoiding the unbounded frequency commands required by naive inversion.

5. Significance and Claims

The paper claims to provide a singularity-robust extension of feedback linearization. Its significance lies in:

Unified Framework: It offers a single formula that works for both regular tracking and tracking through singularities, eliminating the need for switching logic or case-by-case analysis.
Boundedness without Accuracy Loss: Unlike damped least squares, which trades accuracy for boundedness, this method is exact (up to $O(1/k)$ ) in regular regions and only introduces bounded transients at the singularity.
Geometric Insight: It clarifies the geometric conditions (transversality) required to cross a singularity and explicitly characterizes the trade-off between maintaining parameter locking and changing solution branches.
Practical Applicability: The method is demonstrated on diverse systems, from simple kinematic models to complex power electronic converters, showing that it can handle both "crossing" and "reflection" scenarios depending on the physical constraints and orientation choice.

The authors modestly note that the method does not enlarge the class of regulable systems in terms of structural properties (it still requires a well-defined relative degree and minimum-phase zero dynamics). Instead, it enlarges the admissible operating envelope of a given system, allowing it to traverse trajectories that would otherwise cause control divergence. The paper concludes that while it cannot manufacture controllability where none exists, it provides a graceful, bounded failure mode for removable singularities.