Consider the homogeneous continuous-time LTV system \( \dot{\mathbf{x}}(t)=A(t)\mathbf{x}(t) \), where \( A(t)\in\mathbb{R}^{n\times n} \) is piecewise continuous on every finite time interval. Its solution is written using the state-transition matrix:

\[ \mathbf{x}(t)=\Phi(t,t_0)\mathbf{x}_0,\qquad \Phi(t_0,t_0)=I,\qquad \frac{\partial}{\partial t}\Phi(t,t_0) =A(t)\Phi(t,t_0). \]

In LTI systems, \( \Phi(t,t_0)=e^{A(t-t_0)} \), so stability depends only on the elapsed time \( t-t_0 \). In LTV systems, \( \Phi(t,t_0) \) generally depends on both \( t \) and \( t_0 \). Therefore, it is possible for the system to behave well for one initial time but poorly for another.

The central object of this lesson is not the instantaneous eigenvalues of \( A(t) \), but the family of operators \( \Phi(t,t_0) \) for all \( t\ge t_0 \). A meaningful LTV stability definition must control this family uniformly with respect to initial time whenever the word uniform is used.

flowchart TD
  A["LTV system: xdot = A(t) x"] --> B["Compute or estimate Phi(t,t0)"]
  B --> C["Bound ||Phi(t,t0)||"]
  C --> D{"Bound independent \nof t0?"}
  D -->|"yes"| E["Uniform stability family"]
  D -->|"no"| F["Nonuniform stability \npossible"]
  E --> G{"Decay to \nzero uniformly?"}
  G -->|"yes"| H["Uniform asymptotic stability"]
  G -->|"no"| I["Uniform stability only"]
  H --> J{"Exponential \ndecay bound?"}
  J -->|"yes"| K["Uniform exponential \nstability"]
  J -->|"no"| L["Uniform asymptotic \nbut not exponential"]
        

The origin \( \mathbf{x}=\mathbf{0} \) is always an equilibrium of the homogeneous LTV system. For a forced LTV system \( \dot{\mathbf{x}}=A(t)\mathbf{x}+B(t)\mathbf{u}(t) \), internal stability is normally studied by first examining the homogeneous part. The forced solution is

\[ \mathbf{x}(t)=\Phi(t,t_0)\mathbf{x}_0+ \int_{t_0}^{t}\Phi(t,\tau)B(\tau)\mathbf{u}(\tau)\,d\tau. \]

This lesson focuses on the homogeneous term because stability of the zero-input motion is the foundation for later input-output and bounded-input bounded-state results. For a norm \( \|\cdot\| \), the induced matrix norm satisfies

\[ \|\mathbf{x}(t)\|\le \|\Phi(t,t_0)\|\;\|\mathbf{x}_0\|. \]

Thus every stability property can be translated into a property of \( \|\Phi(t,t_0)\| \).

Stability in the sense of Lyapunov. The origin is stable if, for every initial time \( t_0 \) and every \( \varepsilon > 0 \), there exists a number \( \delta(\varepsilon,t_0)>0 \) such that

\[ \|\mathbf{x}_0\|<\delta(\varepsilon,t_0) \quad\Longrightarrow\quad \|\Phi(t,t_0)\mathbf{x}_0\|<\varepsilon,\qquad \forall t\ge t_0. \]

This definition allows the admissible radius \( \delta \) to depend on the initial time. That dependence is often undesirable in control because the controller should not be safe only for certain starting dates or phases of a time-varying plant.

Uniform stability. The origin is uniformly stable if, for every \( \varepsilon > 0 \), there exists \( \delta(\varepsilon)>0 \), independent of \( t_0 \), such that

\[ \|\mathbf{x}_0\|<\delta(\varepsilon) \quad\Longrightarrow\quad \|\Phi(t,t_0)\mathbf{x}_0\|<\varepsilon,\qquad \forall t\ge t_0,\;\forall t_0\ge 0. \]

For linear systems, uniform stability has a particularly clean state-transition-matrix characterization:

\[ \boxed{\text{Uniform stability} \quad\Longleftrightarrow\quad \exists M\ge 1\;\text{such that}\; \|\Phi(t,t_0)\|\le M,\quad \forall t\ge t_0\ge 0.} \]

Proof. Suppose such an \( M \) exists. Then

\[ \|\mathbf{x}(t)\|\le M\|\mathbf{x}_0\|. \]

Given \( \varepsilon > 0 \), choose \( \delta=\varepsilon/M \). Then \( \|\mathbf{x}_0\|<\delta \) implies \( \|\mathbf{x}(t)\|<\varepsilon \) for all \( t\ge t_0 \), uniformly in \( t_0 \).

Conversely, assume uniform stability. Take \( \varepsilon=1 \). There exists \( \delta>0 \) such that \( \|\mathbf{x}_0\|<\delta \) implies \( \|\Phi(t,t_0)\mathbf{x}_0\|<1 \) for all \( t\ge t_0 \). For any unit vector \( \mathbf{v} \), choose \( \mathbf{x}_0=(\delta/2)\mathbf{v} \). Then

\[ \frac{\delta}{2}\|\Phi(t,t_0)\mathbf{v}\|<1 \quad\Longrightarrow\quad \|\Phi(t,t_0)\mathbf{v}\|<\frac{2}{\delta}. \]

Taking the supremum over all unit vectors gives \( \|\Phi(t,t_0)\|\le 2/\delta \). Hence \( M=2/\delta \) is a uniform bound.

Asymptotic stability. The origin is asymptotically stable if it is stable and, for every initial time \( t_0 \), there exists a radius \( c(t_0)>0 \) such that

\[ \|\mathbf{x}_0\|<c(t_0) \quad\Longrightarrow\quad \lim_{t\to\infty}\|\Phi(t,t_0)\mathbf{x}_0\|=0. \]

For a linear system, asymptotic attractivity of the origin is equivalent to the decay of the transition matrix for each fixed initial time:

\[ \lim_{t\to\infty}\|\Phi(t,t_0)\|=0,\qquad \text{for each fixed }t_0. \]

Uniform asymptotic stability. The origin is uniformly asymptotically stable if it is uniformly stable and uniformly attractive. Uniform attractivity means there exists a radius \( c>0 \), independent of \( t_0 \), such that for every \( \eta>0 \), there exists a time \( T(\eta)>0 \), independent of \( t_0 \), satisfying

\[ \|\mathbf{x}_0\|<c \quad\Longrightarrow\quad \|\Phi(t,t_0)\mathbf{x}_0\|<\eta,\qquad \forall t\ge t_0+T(\eta),\;\forall t_0\ge 0. \]

For linear systems, this can be expressed directly as a uniform decay condition:

\[ \boxed{\text{Uniform asymptotic stability} \quad\Longleftrightarrow\quad \|\Phi(t,t_0)\|\le \beta(t-t_0),\quad \beta(s)\to 0\text{ as }s\to\infty,} \]

where \( \beta \) is nonnegative, bounded, and depends only on elapsed time \( s=t-t_0 \), not on the initial time.

The strongest common LTV stability notion in finite-dimensional linear control is uniform exponential stability. The origin is uniformly exponentially stable if there exist constants \( M\ge 1 \) and \( \alpha>0 \) such that

\[ \boxed{\|\Phi(t,t_0)\|\le M e^{-\alpha(t-t_0)},\qquad \forall t\ge t_0\ge 0.} \]

This estimate implies uniform stability by taking \( \|\Phi(t,t_0)\|\le M \), and it implies uniform attractivity because the right-hand side tends to zero as \( t-t_0\to\infty \), independently of \( t_0 \).

\[ \text{Uniform exponential stability} \Longrightarrow \text{uniform asymptotic stability} \Longrightarrow \text{uniform stability}. \]

The converses are not automatic. For example, a scalar system may be uniformly stable without being uniformly attractive, and uniform asymptotic decay need not have a single exponential rate unless additional regularity or finite-dimensional linear assumptions are used.

Example 1: uniformly exponentially stable scalar LTV system. Consider

\[ \dot{x}(t)=\left(-\frac{1}{2}+\frac{1}{4}\sin t\right)x(t). \]

The scalar transition function is

\[ \Phi(t,t_0)= \exp\left[-\frac{1}{2}(t-t_0)+\frac{1}{4} \left(\cos t_0-\cos t\right)\right]. \]

Since \( \cos t_0-\cos t\le 2 \), we have

\[ |\Phi(t,t_0)|\le e^{1/2}e^{-(1/2)(t-t_0)}. \]

Therefore the system is uniformly exponentially stable with \( M=e^{1/2} \) and \( \alpha=1/2 \).

Example 2: uniformly stable but not uniformly attractive. Consider

\[ \dot{x}(t)=-\frac{1}{1+t}x(t),\qquad t\ge 0. \]

The transition function is

\[ \Phi(t,t_0)= \exp\left[-\int_{t_0}^{t}\frac{1}{1+\tau}\,d\tau\right] =\frac{1+t_0}{1+t}. \]

Since \( |\Phi(t,t_0)|\le 1 \) for all \( t\ge t_0 \), the system is uniformly stable. For each fixed \( t_0 \), \( \Phi(t,t_0)\to 0 \) as \( t\to\infty \). However, convergence is not uniform:

\[ \Phi(t_0+T,t_0)=\frac{1+t_0}{1+t_0+T} \quad\Longrightarrow\quad \sup_{t_0\ge 0}\Phi(t_0+T,t_0)=1,\qquad \forall T>0. \]

Hence no finite horizon \( T \) makes all trajectories uniformly small independently of initial time.

A time-varying Lyapunov function has the form \( V(\mathbf{x},t) \). For linear systems, the most important quadratic candidate is

\[ V(\mathbf{x},t)=\mathbf{x}^{T}P(t)\mathbf{x},\qquad P(t)=P^{T}(t)>0. \]

Its derivative along trajectories of \( \dot{\mathbf{x}}=A(t)\mathbf{x} \) is

\[ \dot{V}(\mathbf{x},t)= \mathbf{x}^{T}\left(\dot{P}(t)+A^{T}(t)P(t)+P(t)A(t)\right)\mathbf{x}. \]

Suppose there exist constants \( m_1,m_2,m_3>0 \) such that

\[ m_1\|\mathbf{x}\|^2\le V(\mathbf{x},t)\le m_2\|\mathbf{x}\|^2,\qquad \dot{V}(\mathbf{x},t)\le -m_3\|\mathbf{x}\|^2. \]

Then

\[ \dot{V}\le -\frac{m_3}{m_2}V \quad\Longrightarrow\quad V(t)\le V(t_0)\exp\left[-\frac{m_3}{m_2}(t-t_0)\right]. \]

Using the lower and upper quadratic bounds gives

\[ \|\mathbf{x}(t)\|\le \sqrt{\frac{m_2}{m_1}}\, \exp\left[-\frac{m_3}{2m_2}(t-t_0)\right]\|\mathbf{x}_0\|. \]

Therefore the system is uniformly exponentially stable with \( M=\sqrt{m_2/m_1} \) and \( \alpha=m_3/(2m_2) \).

A common matrix inequality version is obtained if \( P(t) \) satisfies

\[ \dot{P}(t)+A^{T}(t)P(t)+P(t)A(t)\le -Q(t),\qquad Q(t)=Q^{T}(t)\ge qI,\quad q>0, \]

together with uniform positive definiteness

\[ p_1 I\le P(t)\le p_2 I,\qquad p_1,p_2>0. \]

Then the preceding constants may be selected as \( m_1=p_1 \), \( m_2=p_2 \), and \( m_3=q \).

In practical engineering work, one rarely obtains a closed-form transition matrix. The usual analysis combines analytic bounds, numerical integration, and Lyapunov inequalities.

flowchart TD
  A["Start with A(t)"] --> B["Check regularity and boundedness"]
  B --> C["Try analytic Phi(t,t0) \nif scalar or triangular"]
  C --> D["Estimate ||Phi(t,t0)|| \nover t0 and horizons"]
  B --> E["Search for P(t) Lyapunov inequality"]
  D --> F["Candidate stability class"]
  E --> F
  F --> G["Uniform bound?"]
  G -->|"no"| H["Nonuniform or unstable behavior"]
  G -->|"yes"| I["Check decay with elapsed time"]
  I --> J["Uniform, uniform asymptotic, or exponential"]
        

This script evaluates scalar transition functions and numerically integrates \( \dot{\Phi}=A(t)\Phi \) for a two-state LTV oscillator using fourth-order Runge-Kutta integration.

"""
Chapter29_Lesson3.py

Numerical experiments for Lesson 3:
Stability notions for continuous-time linear time-varying (LTV) systems.
"""

import math
import numpy as np


def phi_uniform_exponential_scalar(t, t0):
    return math.exp(-0.5 * (t - t0) + 0.25 * (math.cos(t0) - math.cos(t)))


def phi_uniform_stable_not_uniform_attractive(t, t0):
    return (1.0 + t0) / (1.0 + t)


def ltv_matrix_A(t):
    k = 1.0 + 0.20 * math.sin(t)
    c = 0.80 + 0.10 * math.cos(2.0 * t)
    return np.array([[0.0, 1.0], [-k, -c]], dtype=float)


def rk4_phi(A_func, t0, t1, h=0.002):
    if t1 < t0:
        raise ValueError("This routine assumes t1 >= t0.")
    n = int(math.ceil((t1 - t0) / h))
    if n == 0:
        return np.eye(2)

    h_eff = (t1 - t0) / n
    t = t0
    Phi = np.eye(2)

    def f(time, X):
        return A_func(time) @ X

    for _ in range(n):
        K1 = f(t, Phi)
        K2 = f(t + 0.5 * h_eff, Phi + 0.5 * h_eff * K1)
        K3 = f(t + 0.5 * h_eff, Phi + 0.5 * h_eff * K2)
        K4 = f(t + h_eff, Phi + h_eff * K3)
        Phi = Phi + (h_eff / 6.0) * (K1 + 2.0 * K2 + 2.0 * K3 + K4)
        t += h_eff

    return Phi


def main():
    print("Scalar uniformly exponentially stable example")
    M = math.exp(0.5)
    alpha = 0.5

    for tau in [0, 1, 2, 5, 10]:
        ratios = []
        for t0 in np.linspace(0, 20, 41):
            phi = abs(phi_uniform_exponential_scalar(t0 + tau, t0))
            bound = M * math.exp(-alpha * tau)
            ratios.append(phi / bound)
        print(f"tau={tau}, max |Phi|/bound = {max(ratios):.6f}")

    print("\nUniformly stable but not uniformly attractive example")
    for T in [1, 5, 20]:
        values = [
            phi_uniform_stable_not_uniform_attractive(t0 + T, t0)
            for t0 in [0, 10, 100, 1000, 10000]
        ]
        print(f"T={T}, Phi values for growing t0 = {values}")

    print("\n2x2 transition-matrix norm estimates")
    for tau in [1, 2, 5, 10]:
        norms = []
        for t0 in np.linspace(0, 5, 6):
            Phi = rk4_phi(ltv_matrix_A, t0, t0 + tau, h=0.005)
            norms.append(np.linalg.norm(Phi, 2))
        print(f"tau={tau}, max sampled ||Phi||_2 = {max(norms):.6f}")


if __name__ == "__main__":
    main()
      

The C++ program implements the same RK4 transition-matrix integration from scratch. It avoids external linear algebra libraries so students can see the numerical propagation of \( \Phi(t,t_0) \) explicitly.

#include <cmath>
#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <vector>

struct Matrix2 {
    double v[2][2];
};

Matrix2 zero_matrix() {
    Matrix2 M;
    M.v[0][0] = 0.0; M.v[0][1] = 0.0;
    M.v[1][0] = 0.0; M.v[1][1] = 0.0;
    return M;
}

Matrix2 identity_matrix() {
    Matrix2 M = zero_matrix();
    M.v[0][0] = 1.0;
    M.v[1][1] = 1.0;
    return M;
}

Matrix2 add(Matrix2 A, Matrix2 B) {
    Matrix2 C = zero_matrix();
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            C.v[i][j] = A.v[i][j] + B.v[i][j];
        }
    }
    return C;
}

Matrix2 scale(Matrix2 A, double s) {
    Matrix2 C = zero_matrix();
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            C.v[i][j] = s * A.v[i][j];
        }
    }
    return C;
}

Matrix2 multiply(Matrix2 A, Matrix2 B) {
    Matrix2 C = zero_matrix();
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            for (int k = 0; k < 2; ++k) {
                C.v[i][j] += A.v[i][k] * B.v[k][j];
            }
        }
    }
    return C;
}

double frobenius_norm(Matrix2 A) {
    double s = 0.0;
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            s += A.v[i][j] * A.v[i][j];
        }
    }
    return std::sqrt(s);
}

Matrix2 A_of_t(double t) {
    Matrix2 A = zero_matrix();
    double k = 1.0 + 0.20 * std::sin(t);
    double c = 0.80 + 0.10 * std::cos(2.0 * t);
    A.v[0][0] = 0.0;
    A.v[0][1] = 1.0;
    A.v[1][0] = -k;
    A.v[1][1] = -c;
    return A;
}

Matrix2 f(double t, Matrix2 Phi) {
    return multiply(A_of_t(t), Phi);
}

Matrix2 rk4_phi(double t0, double t1, double h) {
    if (t1 < t0) {
        throw std::invalid_argument("This routine assumes t1 >= t0.");
    }

    int n = static_cast<int>(std::ceil((t1 - t0) / h));
    if (n == 0) {
        return identity_matrix();
    }

    double h_eff = (t1 - t0) / static_cast<double>(n);
    double t = t0;
    Matrix2 Phi = identity_matrix();

    for (int step = 0; step < n; ++step) {
        Matrix2 K1 = f(t, Phi);
        Matrix2 K2 = f(t + 0.5 * h_eff, add(Phi, scale(K1, 0.5 * h_eff)));
        Matrix2 K3 = f(t + 0.5 * h_eff, add(Phi, scale(K2, 0.5 * h_eff)));
        Matrix2 K4 = f(t + h_eff, add(Phi, scale(K3, h_eff)));

        Matrix2 incr = add(add(K1, scale(K2, 2.0)), add(scale(K3, 2.0), K4));
        Phi = add(Phi, scale(incr, h_eff / 6.0));
        t += h_eff;
    }
    return Phi;
}

double phi_uniform_exponential_scalar(double t, double t0) {
    return std::exp(-0.5 * (t - t0) + 0.25 * (std::cos(t0) - std::cos(t)));
}

double phi_uniform_stable_not_uniform_attractive(double t, double t0) {
    return (1.0 + t0) / (1.0 + t);
}

int main() {
    std::cout << std::fixed << std::setprecision(6);

    double M = std::exp(0.5);
    double alpha = 0.5;

    for (double tau : std::vector<double>{0.0, 1.0, 2.0, 5.0, 10.0}) {
        double max_ratio = 0.0;
        for (int i = 0; i <= 40; ++i) {
            double t0 = 0.5 * i;
            double phi = std::abs(phi_uniform_exponential_scalar(t0 + tau, t0));
            double bound = M * std::exp(-alpha * tau);
            max_ratio = std::max(max_ratio, phi / bound);
        }
        std::cout << "tau=" << tau
                  << ", max |Phi|/bound = " << max_ratio << "\n";
    }

    for (double tau : std::vector<double>{1.0, 2.0, 5.0, 10.0}) {
        double max_norm = 0.0;
        for (int i = 0; i <= 5; ++i) {
            double t0 = static_cast<double>(i);
            Matrix2 Phi = rk4_phi(t0, t0 + tau, 0.005);
            max_norm = std::max(max_norm, frobenius_norm(Phi));
        }
        std::cout << "tau=" << tau
                  << ", max sampled ||Phi||_F = " << max_norm << "\n";
    }

    return 0;
}
      

public class Chapter29_Lesson3 {
    static double[][] zeros() {
        return new double[2][2];
    }

    static double[][] identity() {
        double[][] M = zeros();
        M[0][0] = 1.0;
        M[1][1] = 1.0;
        return M;
    }

    static double[][] add(double[][] A, double[][] B) {
        double[][] C = zeros();
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                C[i][j] = A[i][j] + B[i][j];
            }
        }
        return C;
    }

    static double[][] scale(double[][] A, double s) {
        double[][] C = zeros();
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                C[i][j] = s * A[i][j];
            }
        }
        return C;
    }

    static double[][] multiply(double[][] A, double[][] B) {
        double[][] C = zeros();
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 2; k++) {
                    C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return C;
    }

    static double[][] aOfT(double t) {
        double[][] A = zeros();
        double k = 1.0 + 0.20 * Math.sin(t);
        double c = 0.80 + 0.10 * Math.cos(2.0 * t);
        A[0][0] = 0.0;
        A[0][1] = 1.0;
        A[1][0] = -k;
        A[1][1] = -c;
        return A;
    }

    static double[][] rk4Phi(double t0, double t1, double h) {
        if (t1 < t0) {
            throw new IllegalArgumentException("This routine assumes t1 >= t0.");
        }

        int n = (int)Math.ceil((t1 - t0) / h);
        if (n == 0) {
            return identity();
        }

        double hEff = (t1 - t0) / n;
        double t = t0;
        double[][] Phi = identity();

        for (int step = 0; step < n; step++) {
            double[][] K1 = multiply(aOfT(t), Phi);
            double[][] K2 = multiply(aOfT(t + 0.5 * hEff),
                    add(Phi, scale(K1, 0.5 * hEff)));
            double[][] K3 = multiply(aOfT(t + 0.5 * hEff),
                    add(Phi, scale(K2, 0.5 * hEff)));
            double[][] K4 = multiply(aOfT(t + hEff),
                    add(Phi, scale(K3, hEff)));

            double[][] incr = add(add(K1, scale(K2, 2.0)), add(scale(K3, 2.0), K4));
            Phi = add(Phi, scale(incr, hEff / 6.0));
            t += hEff;
        }
        return Phi;
    }

    static double frobeniusNorm(double[][] A) {
        double s = 0.0;
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                s += A[i][j] * A[i][j];
            }
        }
        return Math.sqrt(s);
    }

    static double phiUniformExponentialScalar(double t, double t0) {
        return Math.exp(-0.5 * (t - t0) + 0.25 * (Math.cos(t0) - Math.cos(t)));
    }

    static double phiUniformStableNotUniformAttractive(double t, double t0) {
        return (1.0 + t0) / (1.0 + t);
    }

    public static void main(String[] args) {
        double M = Math.exp(0.5);
        double alpha = 0.5;

        for (double tau : new double[] {0.0, 1.0, 2.0, 5.0, 10.0}) {
            double maxRatio = 0.0;
            for (int i = 0; i <= 40; i++) {
                double t0 = 0.5 * i;
                double phi = Math.abs(phiUniformExponentialScalar(t0 + tau, t0));
                double bound = M * Math.exp(-alpha * tau);
                maxRatio = Math.max(maxRatio, phi / bound);
            }
            System.out.printf("tau=%.1f, max |Phi|/bound = %.6f%n", tau, maxRatio);
        }

        for (double tau : new double[] {1.0, 2.0, 5.0, 10.0}) {
            double maxNorm = 0.0;
            for (int i = 0; i <= 5; i++) {
                double t0 = (double)i;
                double[][] Phi = rk4Phi(t0, t0 + tau, 0.005);
                maxNorm = Math.max(maxNorm, frobeniusNorm(Phi));
            }
            System.out.printf("tau=%.1f, max sampled ||Phi||_F = %.6f%n",
                    tau, maxNorm);
        }
    }
}
      

MATLAB can directly integrate the transition matrix by stacking the columns of \( \Phi \). The script below uses a compact RK4 method so the numerical idea remains transparent. In Simulink, the same LTV system can be implemented using a MATLAB Function block that receives \( t \) from a Clock block and outputs \( A(t)x \).

% Chapter29_Lesson3.m

function Chapter29_Lesson3()
    fprintf('Scalar uniformly exponentially stable example\n');
    M = exp(0.5);
    alpha = 0.5;

    for tau = [0, 1, 2, 5, 10]
        ratios = [];
        for t0 = linspace(0, 20, 41)
            phi = abs(phi_uniform_exponential_scalar(t0 + tau, t0));
            bound = M * exp(-alpha * tau);
            ratios(end + 1) = phi / bound;
        end
        fprintf('tau=%5.1f, max |Phi|/bound = %.6f\n', tau, max(ratios));
    end

    fprintf('\nUniformly stable but not uniformly attractive example\n');
    for T = [1, 5, 20]
        fprintf('T=%5.1f: ', T);
        for t0 = [0, 10, 100, 1000, 10000]
            fprintf('%.6f ', phi_uniform_stable_not_uniform_attractive(t0 + T, t0));
        end
        fprintf('\n');
    end

    fprintf('\n2x2 transition-matrix Frobenius norm estimates\n');
    for tau = [1, 2, 5, 10]
        norms = [];
        for t0 = linspace(0, 5, 6)
            Phi = rk4_phi(t0, t0 + tau, 0.005);
            norms(end + 1) = norm(Phi, 'fro');
        end
        fprintf('tau=%5.1f, max sampled ||Phi||_F = %.6f\n', tau, max(norms));
    end
end

function y = phi_uniform_exponential_scalar(t, t0)
    y = exp(-0.5 * (t - t0) + 0.25 * (cos(t0) - cos(t)));
end

function y = phi_uniform_stable_not_uniform_attractive(t, t0)
    y = (1.0 + t0) / (1.0 + t);
end

function A = A_of_t(t)
    k = 1.0 + 0.20 * sin(t);
    c = 0.80 + 0.10 * cos(2.0 * t);
    A = [0.0, 1.0; -k, -c];
end

function Phi = rk4_phi(t0, t1, h)
    if t1 < t0
        error('This routine assumes t1 >= t0.');
    end

    n = ceil((t1 - t0) / h);
    if n == 0
        Phi = eye(2);
        return;
    end

    h_eff = (t1 - t0) / n;
    t = t0;
    Phi = eye(2);

    for step = 1:n
        K1 = A_of_t(t) * Phi;
        K2 = A_of_t(t + 0.5 * h_eff) * (Phi + 0.5 * h_eff * K1);
        K3 = A_of_t(t + 0.5 * h_eff) * (Phi + 0.5 * h_eff * K2);
        K4 = A_of_t(t + h_eff) * (Phi + h_eff * K3);
        Phi = Phi + (h_eff / 6.0) * (K1 + 2.0 * K2 + 2.0 * K3 + K4);
        t = t + h_eff;
    end
end
      

The Mathematica notebook evaluates the scalar transition functions symbolically and numerically. It is especially useful for showing that one example satisfies an exponential bound while the other fails uniform attractivity.

ClearAll[phiUES, phiUSNotUA, ratioUES]

phiUES[t_, t0_] := Exp[-0.5 (t - t0) + 0.25 (Cos[t0] - Cos[t])]
phiUSNotUA[t_, t0_] := (1 + t0)/(1 + t)

M = Exp[0.5];
alpha = 0.5;
ratioUES[t_, t0_] := Abs[phiUES[t, t0]]/(M Exp[-alpha (t - t0)])

Table[
  {tau, Max[Table[ratioUES[t0 + tau, t0], {t0, 0, 20, 0.5}]]},
  {tau, {0, 1, 2, 5, 10}}
] // TableForm

Table[
  {T, Table[phiUSNotUA[t0 + T, t0], {t0, {0, 10, 100, 1000, 10000}}]},
  {T, {1, 5, 20}}
] // TableForm
      

Problem 1 (Uniform Stability Criterion): Let \( \dot{\mathbf{x}}=A(t)\mathbf{x} \) have transition matrix \( \Phi(t,t_0) \). Prove that the origin is uniformly stable if \( \|\Phi(t,t_0)\|\le M \) for all \( t\ge t_0\ge 0 \).

Solution: From the solution formula,

\[ \|\mathbf{x}(t)\|\le \|\Phi(t,t_0)\|\|\mathbf{x}_0\| \le M\|\mathbf{x}_0\|. \]

Given \( \varepsilon>0 \), choose \( \delta=\varepsilon/M \). Then \( \|\mathbf{x}_0\|<\delta \) implies \( \|\mathbf{x}(t)\|<\varepsilon \) for all \( t\ge t_0 \), and the same \( \delta \) works for all initial times.

Problem 2 (Scalar Uniform Exponential Stability): Determine whether \( \dot{x}=(-2+\sin t)x \) is uniformly exponentially stable.

Solution: The transition function is

\[ \Phi(t,t_0)= \exp\left[-2(t-t_0)+\int_{t_0}^{t}\sin \tau\,d\tau\right] = \exp\left[-2(t-t_0)-\cos t+\cos t_0\right]. \]

Since \( -\cos t+\cos t_0\le 2 \),

\[ |\Phi(t,t_0)|\le e^2 e^{-2(t-t_0)}. \]

Hence the system is uniformly exponentially stable with \( M=e^2 \) and \( \alpha=2 \).

Problem 3 (Uniform Stability Without Uniform Attractivity): Show that \( \dot{x}=-x/(1+t) \) is uniformly stable but not uniformly attractive.

Solution: The transition function is

\[ \Phi(t,t_0)=\frac{1+t_0}{1+t}. \]

For \( t\ge t_0 \), this satisfies \( |\Phi(t,t_0)|\le 1 \), so the system is uniformly stable. However, for any fixed horizon \( T>0 \),

\[ \Phi(t_0+T,t_0)=\frac{1+t_0}{1+t_0+T}\to 1 \quad\text{as}\quad t_0\to\infty. \]

Therefore convergence to zero cannot be made uniform in \( t_0 \).

Problem 4 (Lyapunov Exponential Bound): Suppose \( V(\mathbf{x},t) \) satisfies

\[ m_1\|\mathbf{x}\|^2\le V(\mathbf{x},t)\le m_2\|\mathbf{x}\|^2,\qquad \dot{V}(\mathbf{x},t)\le -m_3\|\mathbf{x}\|^2. \]

Derive constants \( M \) and \( \alpha \) for a uniform exponential stability bound.

Solution: Since \( V\le m_2\|\mathbf{x}\|^2 \),

\[ \dot{V}\le -\frac{m_3}{m_2}V. \]

Therefore,

\[ V(t)\le V(t_0)e^{-(m_3/m_2)(t-t_0)}. \]

Using the quadratic bounds gives

\[ \|\mathbf{x}(t)\|\le \sqrt{\frac{m_2}{m_1}}\, e^{-(m_3/(2m_2))(t-t_0)}\|\mathbf{x}_0\|. \]

Thus \( M=\sqrt{m_2/m_1} \) and \( \alpha=m_3/(2m_2) \).

Problem 5 (Instantaneous Eigenvalues Are Not Enough): Explain why checking eigenvalues of \( A(t) \) at each time is not a reliable LTV stability test.

Solution: LTV stability depends on the accumulated action of \( A(t) \) through \( \Phi(t,t_0) \), not only on instantaneous matrices. Even if the eigenvalues of \( A(t) \) appear stable at each time, rotating eigenvectors and noncommuting matrices can produce transient growth or instability. The correct object is the product-like evolution encoded by the transition matrix.

LTV stability is governed by the state-transition matrix \( \Phi(t,t_0) \). Stability allows dependence on the initial time, whereas uniform stability requires bounds independent of the initial time. Uniform asymptotic stability adds uniform decay, and uniform exponential stability gives the strongest practical estimate: \( \|\Phi(t,t_0)\|\le M e^{-\alpha(t-t_0)} \). The Lyapunov method extends naturally to LTV systems through time-dependent quadratic functions \( V(\mathbf{x},t)=\mathbf{x}^{T}P(t)\mathbf{x} \).