We consider the continuous-time LTV system

\[ \dot{\mathbf{x}}(t)=\mathbf{A}(t)\mathbf{x}(t)+\mathbf{B}(t)\mathbf{u}(t), \qquad \mathbf{y}(t)=\mathbf{C}(t)\mathbf{x}(t)+\mathbf{D}(t)\mathbf{u}(t). \]

The state transition matrix \( \boldsymbol{\Phi}(t,s) \) maps the homogeneous state at time \( s \) to time \( t \). Hence, for \( t_f \ge t_0 \),

\[ \mathbf{x}(t_f)= \boldsymbol{\Phi}(t_f,t_0)\mathbf{x}(t_0)+ \int_{t_0}^{t_f} \boldsymbol{\Phi}(t_f,s)\mathbf{B}(s)\mathbf{u}(s)\,ds. \]

In LTI systems, controllability depends only on the pair \( (\mathbf{A},\mathbf{B}) \). In LTV systems, the answer depends on the whole interval \( [t_0,t_f] \), because the actuator \( \mathbf{B}(s) \) and the transport operator \( \boldsymbol{\Phi}(t_f,s) \) both vary with time.

flowchart TD
  U["input u(s) over interval"] --> B["time-varying actuator B(s)"]
  B --> P["transport by Phi(tf,s)"]
  P --> R["reachable contribution to x(tf)"]
  X0["initial state x(t0)"] --> F["free motion Phi(tf,t0)x(t0)"]
  F --> XF["final state x(tf)"]
  R --> XF
  XF --> C["measured through C(t)"]
  C --> Y["output record y(t)"]
        

The reachable set from \( \mathbf{x}(t_0)=\mathbf{0} \) is

\[ \mathcal{R}(t_0,t_f)= \left\{ \int_{t_0}^{t_f} \boldsymbol{\Phi}(t_f,s)\mathbf{B}(s)\mathbf{u}(s)\,ds : \mathbf{u}\in L_2([t_0,t_f],\mathbb{R}^m) \right\}. \]

The LTV controllability Gramian is

\[ \mathbf{W}_c(t_0,t_f)= \int_{t_0}^{t_f} \boldsymbol{\Phi}(t_f,s)\mathbf{B}(s)\mathbf{B}^{\top}(s) \boldsymbol{\Phi}^{\top}(t_f,s)\,ds. \]

The system is controllable on \( [t_0,t_f] \) if every terminal state \( \mathbf{x}_f\in\mathbb{R}^n \) can be reached at time \( t_f \). Under standard piecewise-continuity assumptions,

\[ (\mathbf{A},\mathbf{B})\text{ controllable on }[t_0,t_f] \quad\Longleftrightarrow\quad \operatorname{rank}\mathbf{W}_c(t_0,t_f)=n. \]

Proof Sketch

If \( \mathbf{W}_c(t_0,t_f) \) is nonsingular, choose

\[ \mathbf{u}^{\star}(s)= \mathbf{B}^{\top}(s)\boldsymbol{\Phi}^{\top}(t_f,s) \mathbf{W}_c^{-1}(t_0,t_f)\mathbf{x}_f. \]

Then substitution into the state equation gives

\[ \int_{t_0}^{t_f} \boldsymbol{\Phi}(t_f,s)\mathbf{B}(s)\mathbf{u}^{\star}(s)\,ds = \mathbf{W}_c(t_0,t_f)\mathbf{W}_c^{-1}(t_0,t_f)\mathbf{x}_f = \mathbf{x}_f. \]

Conversely, if \( \mathbf{W}_c \) is singular, there exists nonzero \( \mathbf{q} \) such that \( \mathbf{q}^{\top}\mathbf{W}_c\mathbf{q}=0 \). But

\[ \mathbf{q}^{\top}\mathbf{W}_c\mathbf{q} = \int_{t_0}^{t_f} \left\| \mathbf{B}^{\top}(s)\boldsymbol{\Phi}^{\top}(t_f,s)\mathbf{q} \right\|_2^2\,ds. \]

Therefore all reachable terminal states are orthogonal to a nonzero direction, so the reachable set cannot be all of \( \mathbb{R}^n \).

Observability asks whether \( \mathbf{x}(t_0) \) can be uniquely recovered from the output record on \( [t_0,t_f] \). With known input removed, the zero-input output is

\[ \mathbf{y}(t)= \mathbf{C}(t)\boldsymbol{\Phi}(t,t_0)\mathbf{x}(t_0). \]

The LTV observability Gramian is

\[ \mathbf{W}_o(t_0,t_f)= \int_{t_0}^{t_f} \boldsymbol{\Phi}^{\top}(s,t_0)\mathbf{C}^{\top}(s)\mathbf{C}(s) \boldsymbol{\Phi}(s,t_0)\,ds. \]

The pair \( (\mathbf{A}(t),\mathbf{C}(t)) \) is observable on \( [t_0,t_f] \) if and only if

\[ \operatorname{rank}\mathbf{W}_o(t_0,t_f)=n. \]

This follows from the output energy identity

\[ \int_{t_0}^{t_f}\mathbf{y}^{\top}(t)\mathbf{y}(t)\,dt = \mathbf{x}^{\top}(t_0)\mathbf{W}_o(t_0,t_f)\mathbf{x}(t_0). \]

If \( \mathbf{W}_o \) is positive definite, every nonzero initial state produces nonzero output energy. If it is singular, some nonzero initial state produces zero output energy and is indistinguishable from the zero state.

4.1 Rotating Actuator Direction

Let \( \mathbf{A}(t)=\mathbf{0} \) and \( \mathbf{B}(t)=[\cos t,\;\sin t]^{\top} \). There is only one scalar input, but its direction changes with time. Since \( \boldsymbol{\Phi}(t,s)=\mathbf{I} \),

\[ \mathbf{W}_c(0,T)= \int_0^T \begin{bmatrix} \cos^2s & \cos s\sin s\\ \cos s\sin s & \sin^2s \end{bmatrix}ds. \]

The changing input direction can span the plane over time. Therefore, unlike a static one-input LTI system with a fixed input direction, this LTV system may be controllable on a finite interval.

4.2 Scalar Observability

For \( \dot{x}(t)=a(t)x(t) \) and \( y(t)=c(t)x(t) \),

\[ \Phi(t,t_0)= \exp\left(\int_{t_0}^{t}a(s)\,ds\right). \]

Hence

\[ W_o(t_0,t_f)= \int_{t_0}^{t_f} c^2(t)\exp\left(2\int_{t_0}^{t}a(s)\,ds\right)dt. \]

The scalar state is observable if this integral is positive.

LTV controllability may depend on both starting time and interval length. A stronger concept is uniform complete controllability. There exist constants \( \alpha_c,\beta_c,T_c > 0 \) such that, for all starting times \( t \),

\[ \alpha_c\mathbf{I} \preceq \mathbf{W}_c(t,t+T_c) \preceq \beta_c\mathbf{I}. \]

Similarly, uniform complete observability means there exist \( \alpha_o,\beta_o,T_o > 0 \) such that

\[ \alpha_o\mathbf{I} \preceq \mathbf{W}_o(t,t+T_o) \preceq \beta_o\mathbf{I}. \]

The lower bound prevents loss of authority or sensing in any state direction. The upper bound prevents numerical blow-up. These uniform concepts are essential in advanced LTV observer and filtering theory.

Let \( \mathbf{z}(t)=\mathbf{T}(t)\mathbf{x}(t) \), where \( \mathbf{T}(t) \) is nonsingular. Then

\[ \dot{\mathbf{z}}(t)= \left( \dot{\mathbf{T}}(t)\mathbf{T}^{-1}(t) +\mathbf{T}(t)\mathbf{A}(t)\mathbf{T}^{-1}(t) \right)\mathbf{z}(t) + \mathbf{T}(t)\mathbf{B}(t)\mathbf{u}(t). \]

The transformed transition matrix satisfies

\[ \boldsymbol{\Phi}_z(t,s)= \mathbf{T}(t)\boldsymbol{\Phi}_x(t,s)\mathbf{T}^{-1}(s). \]

Thus

\[ \mathbf{W}_{c,z}(t_0,t_f)= \mathbf{T}(t_f)\mathbf{W}_{c,x}(t_0,t_f)\mathbf{T}^{\top}(t_f), \]

\[ \mathbf{W}_{o,z}(t_0,t_f)= \mathbf{T}^{-\top}(t_0)\mathbf{W}_{o,x}(t_0,t_f)\mathbf{T}^{-1}(t_0). \]

Rank is preserved. Therefore LTV controllability and observability are system properties, not artifacts of a particular coordinate basis.

A practical numerical workflow is to integrate \( \boldsymbol{\Phi}(t,t_0) \) on a time grid, recover \( \boldsymbol{\Phi}(t_f,s) \) from

\[ \boldsymbol{\Phi}(t_f,s)= \boldsymbol{\Phi}(t_f,t_0)\boldsymbol{\Phi}^{-1}(s,t_0), \]

and then approximate the Gramian integrals by quadrature.

flowchart TD
  A["Choose interval t0 to tf"] --> B["Integrate Phi(t,t0)"]
  B --> C["Store Phi on grid"]
  C --> D["Compute Phi(tf,s) from stored values"]
  D --> E["Accumulate Wc"]
  C --> F["Accumulate Wo"]
  E --> G["Symmetrize Gramians"]
  F --> G
  G --> H["Check rank, eigenvalues, determinant, condition number"]
  H --> I["Interpret controllability and observability"]
        

In floating-point computation, small positive Gramian eigenvalues mean the system may be mathematically controllable or observable but practically ill-conditioned.

File: Chapter29_Lesson4.py

import numpy as np

def A(t):
    return np.array([[0.0, 1.0],
                     [-(2.0 + 0.4*np.sin(t)),
                      -(0.25 + 0.10*np.cos(2.0*t))]])

def B(t):
    return np.array([[0.0],
                     [1.0 + 0.25*np.sin(0.5*t)]])

def C(t):
    return np.array([[1.0, 0.30*np.cos(t)]])

def rk4_phi_step(Phi, t, h):
    f = lambda tt, P: A(tt) @ P
    k1 = f(t, Phi)
    k2 = f(t + 0.5*h, Phi + 0.5*h*k1)
    k3 = f(t + 0.5*h, Phi + 0.5*h*k2)
    k4 = f(t + h, Phi + h*k3)
    return Phi + (h/6.0)*(k1 + 2*k2 + 2*k3 + k4)

def gramians(t0=0.0, tf=6.0, n=4000):
    times = np.linspace(t0, tf, n + 1)
    h = (tf - t0)/n
    Phi = np.eye(2)
    phis = [Phi.copy()]

    for k in range(n):
        Phi = rk4_phi_step(Phi, times[k], h)
        phis.append(Phi.copy())

    Phi_tf_t0 = phis[-1]
    Wc = np.zeros((2, 2))
    Wo = np.zeros((2, 2))

    for k, s in enumerate(times):
        weight = 0.5 if k == 0 or k == n else 1.0
        Phi_s_t0 = phis[k]
        Phi_tf_s = Phi_tf_t0 @ np.linalg.inv(Phi_s_t0)

        Bs = B(s)
        Cs = C(s)

        Wc += weight*h*(Phi_tf_s @ Bs @ Bs.T @ Phi_tf_s.T)
        Wo += weight*h*(Phi_s_t0.T @ Cs.T @ Cs @ Phi_s_t0)

    return Wc, Wo

if __name__ == "__main__":
    Wc, Wo = gramians()
    print("Wc =")
    print(Wc)
    print("eig(Wc) =", np.linalg.eigvalsh((Wc + Wc.T)/2))
    print("rank(Wc) =", np.linalg.matrix_rank(Wc, tol=1e-8))

    print("\nWo =")
    print(Wo)
    print("eig(Wo) =", np.linalg.eigvalsh((Wo + Wo.T)/2))
    print("rank(Wo) =", np.linalg.matrix_rank(Wo, tol=1e-8))
      

File: Chapter29_Lesson4.cpp

#include <array>
#include <cmath>
#include <iostream>

using Mat = std::array<double, 4>;

Mat A(double t) {
    return Mat{0.0, 1.0,
               -(2.0 + 0.4*std::sin(t)),
               -(0.25 + 0.10*std::cos(2.0*t))};
}

std::array<double, 2> B(double t) {
    return std::array<double, 2>{0.0, 1.0 + 0.25*std::sin(0.5*t)};
}

std::array<double, 2> C(double t) {
    return std::array<double, 2>{1.0, 0.30*std::cos(t)};
}

Mat add(Mat X, Mat Y) {
    for (int i = 0; i < 4; ++i) X[i] += Y[i];
    return X;
}

Mat scale(Mat X, double a) {
    for (int i = 0; i < 4; ++i) X[i] *= a;
    return X;
}

Mat mul(Mat X, Mat Y) {
    return Mat{
        X[0]*Y[0] + X[1]*Y[2], X[0]*Y[1] + X[1]*Y[3],
        X[2]*Y[0] + X[3]*Y[2], X[2]*Y[1] + X[3]*Y[3]
    };
}

Mat transpose(Mat X) {
    return Mat{X[0], X[2], X[1], X[3]};
}

double det(Mat X) {
    return X[0]*X[3] - X[1]*X[2];
}

Mat inverse(Mat X) {
    double d = det(X);
    return Mat{X[3]/d, -X[1]/d, -X[2]/d, X[0]/d};
}

Mat outer(std::array<double, 2> u) {
    return Mat{u[0]*u[0], u[0]*u[1], u[1]*u[0], u[1]*u[1]};
}

Mat rk4(Mat Phi, double t, double h) {
    auto f = [](double tt, Mat P) { return mul(A(tt), P); };
    Mat k1 = f(t, Phi);
    Mat k2 = f(t + 0.5*h, add(Phi, scale(k1, 0.5*h)));
    Mat k3 = f(t + 0.5*h, add(Phi, scale(k2, 0.5*h)));
    Mat k4 = f(t + h, add(Phi, scale(k3, h)));
    return add(Phi, scale(add(add(k1, scale(k2, 2.0)), add(scale(k3, 2.0), k4)), h/6.0));
}

int main() {
    const int N = 4000;
    const double t0 = 0.0, tf = 6.0, h = (tf - t0)/N;

    Mat Phi = Mat{1.0, 0.0, 0.0, 1.0};
    Mat PhiGrid[N + 1];
    double timeGrid[N + 1];

    PhiGrid[0] = Phi;
    timeGrid[0] = t0;

    for (int k = 0; k < N; ++k) {
        double t = t0 + k*h;
        Phi = rk4(Phi, t, h);
        PhiGrid[k + 1] = Phi;
        timeGrid[k + 1] = t + h;
    }

    Mat Wc = Mat{0.0, 0.0, 0.0, 0.0};
    Mat Wo = Mat{0.0, 0.0, 0.0, 0.0};
    Mat PhiTfT0 = PhiGrid[N];

    for (int k = 0; k <= N; ++k) {
        double s = timeGrid[k];
        double w = (k == 0 || k == N) ? 0.5 : 1.0;
        Mat PhiST0 = PhiGrid[k];
        Mat PhiTfS = mul(PhiTfT0, inverse(PhiST0));

        Mat BB = outer(B(s));
        Mat CC = outer(C(s));

        Wc = add(Wc, scale(mul(mul(PhiTfS, BB), transpose(PhiTfS)), w*h));
        Wo = add(Wo, scale(mul(mul(transpose(PhiST0), CC), PhiST0), w*h));
    }

    std::cout << "det(Wc) = " << det(Wc) << "\n";
    std::cout << "det(Wo) = " << det(Wo) << "\n";
    return 0;
}
      

File: Chapter29_Lesson4.java

public class Chapter29_Lesson4 {
    static double[][] A(double t) {
        return new double[][] {
            {0.0, 1.0},
            {-(2.0 + 0.4*Math.sin(t)), -(0.25 + 0.10*Math.cos(2.0*t))}
        };
    }

    static double[] B(double t) {
        return new double[] {0.0, 1.0 + 0.25*Math.sin(0.5*t)};
    }

    static double[] C(double t) {
        return new double[] {1.0, 0.30*Math.cos(t)};
    }

    static double[][] mul(double[][] X, double[][] Y) {
        double[][] Z = new double[2][2];
        for (int i = 0; i < 2; ++i)
            for (int j = 0; j < 2; ++j)
                for (int k = 0; k < 2; ++k)
                    Z[i][j] += X[i][k]*Y[k][j];
        return Z;
    }

    static double[][] add(double[][] X, double[][] Y) {
        double[][] Z = new double[2][2];
        for (int i = 0; i < 2; ++i)
            for (int j = 0; j < 2; ++j)
                Z[i][j] = X[i][j] + Y[i][j];
        return Z;
    }

    static double[][] scale(double[][] X, double a) {
        double[][] Z = new double[2][2];
        for (int i = 0; i < 2; ++i)
            for (int j = 0; j < 2; ++j)
                Z[i][j] = a*X[i][j];
        return Z;
    }

    static double[][] transpose(double[][] X) {
        return new double[][] {{X[0][0], X[1][0]}, {X[0][1], X[1][1]}};
    }

    static double det(double[][] X) {
        return X[0][0]*X[1][1] - X[0][1]*X[1][0];
    }

    static double[][] inverse(double[][] X) {
        double d = det(X);
        return new double[][] {{X[1][1]/d, -X[0][1]/d}, {-X[1][0]/d, X[0][0]/d}};
    }

    static double[][] outer(double[] u) {
        return new double[][] {{u[0]*u[0], u[0]*u[1]}, {u[1]*u[0], u[1]*u[1]}};
    }

    static double[][] rk4(double[][] Phi, double t, double h) {
        double[][] k1 = mul(A(t), Phi);
        double[][] k2 = mul(A(t + 0.5*h), add(Phi, scale(k1, 0.5*h)));
        double[][] k3 = mul(A(t + 0.5*h), add(Phi, scale(k2, 0.5*h)));
        double[][] k4 = mul(A(t + h), add(Phi, scale(k3, h)));
        return add(Phi, scale(add(add(k1, scale(k2, 2.0)), add(scale(k3, 2.0), k4)), h/6.0));
    }

    public static void main(String[] args) {
        int N = 4000;
        double t0 = 0.0, tf = 6.0, h = (tf - t0)/N;
        double[][][] phiGrid = new double[N + 1][2][2];
        double[] timeGrid = new double[N + 1];

        double[][] Phi = {{1.0, 0.0}, {0.0, 1.0}};
        phiGrid[0] = Phi;
        timeGrid[0] = t0;

        for (int k = 0; k < N; ++k) {
            double t = t0 + k*h;
            Phi = rk4(Phi, t, h);
            phiGrid[k + 1] = Phi;
            timeGrid[k + 1] = t + h;
        }

        double[][] Wc = new double[2][2];
        double[][] Wo = new double[2][2];
        double[][] PhiTfT0 = phiGrid[N];

        for (int k = 0; k <= N; ++k) {
            double s = timeGrid[k];
            double weight = (k == 0 || k == N) ? 0.5 : 1.0;
            double[][] PhiST0 = phiGrid[k];
            double[][] PhiTfS = mul(PhiTfT0, inverse(PhiST0));

            Wc = add(Wc, scale(mul(mul(PhiTfS, outer(B(s))), transpose(PhiTfS)), weight*h));
            Wo = add(Wo, scale(mul(mul(transpose(PhiST0), outer(C(s))), PhiST0), weight*h));
        }

        System.out.println("det(Wc) = " + det(Wc));
        System.out.println("det(Wo) = " + det(Wo));
    }
}
      

File: Chapter29_Lesson4.m

clear; clc;

t0 = 0.0;
tf = 6.0;
N = 4000;
h = (tf - t0)/N;

times = linspace(t0, tf, N + 1);
Phi = eye(2);
phis = zeros(2, 2, N + 1);
phis(:, :, 1) = Phi;

for k = 1:N
    Phi = rk4_phi(Phi, times(k), h);
    phis(:, :, k + 1) = Phi;
end

PhiTfT0 = phis(:, :, end);
Wc = zeros(2, 2);
Wo = zeros(2, 2);

for k = 1:(N + 1)
    s = times(k);
    weight = 1.0;
    if k == 1 || k == N + 1
        weight = 0.5;
    end

    PhiST0 = phis(:, :, k);
    PhiTfS = PhiTfT0 / PhiST0;

    Wc = Wc + weight*h*(PhiTfS*Bmat(s)*Bmat(s)'*PhiTfS');
    Wo = Wo + weight*h*(PhiST0'*Cmat(s)'*Cmat(s)*PhiST0);
end

disp('Wc ='); disp(Wc);
disp('eig(Wc) ='); disp(eig((Wc + Wc')/2));
disp('rank(Wc) ='); disp(rank(Wc, 1e-8));

disp('Wo ='); disp(Wo);
disp('eig(Wo) ='); disp(eig((Wo + Wo')/2));
disp('rank(Wo) ='); disp(rank(Wo, 1e-8));

function M = Amat(t)
    M = [0.0, 1.0;
        -(2.0 + 0.4*sin(t)), -(0.25 + 0.10*cos(2.0*t))];
end

function M = Bmat(t)
    M = [0.0; 1.0 + 0.25*sin(0.5*t)];
end

function M = Cmat(t)
    M = [1.0, 0.30*cos(t)];
end

function Pnext = rk4_phi(P, t, h)
    k1 = Amat(t)*P;
    k2 = Amat(t + 0.5*h)*(P + 0.5*h*k1);
    k3 = Amat(t + 0.5*h)*(P + 0.5*h*k2);
    k4 = Amat(t + h)*(P + h*k3);
    Pnext = P + (h/6.0)*(k1 + 2*k2 + 2*k3 + k4);
end
      

Simulink note: use a Clock block feeding a MATLAB Function block that outputs \( \mathbf{A}(t),\mathbf{B}(t),\mathbf{C}(t) \). Use an Integrator block for \( \dot{\mathbf{x}}=\mathbf{A}(t)\mathbf{x}+\mathbf{B}(t)\mathbf{u} \). Log the matrices and compute the Gramians offline using the same quadrature method.

File: Chapter29_Lesson4.nb

ClearAll["Global`*"];

t0 = 0.0;
tf = 6.0;

A[t_] := {{0.0, 1.0},
  {-(2.0 + 0.4 Sin[t]), -(0.25 + 0.10 Cos[2.0 t])}};

Bmat[t_] := {{0.0}, {1.0 + 0.25 Sin[0.5 t]}};

Cmat[t_] := {{1.0, 0.30 Cos[t]}};

phiSol = NDSolveValue[
   {
    Phi'[t] == A[t].Phi[t],
    Phi[t0] == IdentityMatrix[2]
    },
   Phi,
   {t, t0, tf}
   ];

PhiFromT0[s_] := phiSol[s];
PhiFromSToTf[s_] := phiSol[tf].Inverse[phiSol[s]];

Wc = NIntegrate[
   Evaluate[
    PhiFromSToTf[s].Bmat[s].Transpose[Bmat[s]].Transpose[PhiFromSToTf[s]]
    ],
   {s, t0, tf}
   ];

Wo = NIntegrate[
   Evaluate[
    Transpose[PhiFromT0[s]].Transpose[Cmat[s]].Cmat[s].PhiFromT0[s]
    ],
   {s, t0, tf}
   ];

Print["Wc = "];
Print[MatrixForm[Wc]];
Print["Eigenvalues of Wc = ", Eigenvalues[(Wc + Transpose[Wc])/2]];
Print["Rank of Wc = ", MatrixRank[Wc]];

Print["Wo = "];
Print[MatrixForm[Wo]];
Print["Eigenvalues of Wo = ", Eigenvalues[(Wo + Transpose[Wo])/2]];
Print["Rank of Wo = ", MatrixRank[Wo]];
      

Problem 1: Let \( \mathbf{A}(t)=\mathbf{0} \) and \( \mathbf{B}(t)=[\cos t,\;\sin t]^{\top} \). Compute \( \mathbf{W}_c(0,T) \).

Solution:

\[ \mathbf{W}_c(0,T)= \begin{bmatrix} T/2+\sin(2T)/4 & (1-\cos(2T))/4\\ (1-\cos(2T))/4 & T/2-\sin(2T)/4 \end{bmatrix}. \]

Its determinant is

\[ \det\mathbf{W}_c(0,T)=\frac{T^2-\sin^2T}{4}. \]

For every \( T > 0 \), this determinant is positive, so the system is controllable on every nonzero interval.

Problem 2: For \( \dot{x}=a(t)x \) and \( y=c(t)x \), give the scalar observability condition.

Solution:

\[ W_o(t_0,t_f)= \int_{t_0}^{t_f} c^2(t)\exp\left(2\int_{t_0}^{t}a(s)\,ds\right)dt. \]

Since the exponential factor is positive, the scalar system is observable if and only if this integral is positive.

Problem 3: Suppose \( \mathbf{W}_c(t_0,t_f) \) is nonsingular. Verify that the input \( \mathbf{u}^{\star}(s)=\mathbf{B}^{\top}(s) \boldsymbol{\Phi}^{\top}(t_f,s)\mathbf{W}_c^{-1}\mathbf{x}_f \) reaches \( \mathbf{x}_f \) from zero.

Solution:

\[ \mathbf{x}(t_f)= \int_{t_0}^{t_f} \boldsymbol{\Phi}(t_f,s)\mathbf{B}(s)\mathbf{B}^{\top}(s) \boldsymbol{\Phi}^{\top}(t_f,s)\mathbf{W}_c^{-1}\mathbf{x}_f\,ds = \mathbf{W}_c\mathbf{W}_c^{-1}\mathbf{x}_f = \mathbf{x}_f. \]

Problem 4: Explain why small positive Gramian eigenvalues are important in engineering interpretation.

Solution: A full-rank Gramian implies mathematical controllability or observability. However, if the smallest eigenvalue is very close to zero, the corresponding state direction is weak. For controllability, reaching that direction requires high input energy. For observability, that direction produces weak output energy and is sensitive to noise.

Problem 5: Show that a time-varying coordinate change preserves controllability rank.

Solution: With \( \mathbf{z}(t)=\mathbf{T}(t)\mathbf{x}(t) \),

\[ \mathbf{W}_{c,z}(t_0,t_f)= \mathbf{T}(t_f)\mathbf{W}_{c,x}(t_0,t_f)\mathbf{T}^{\top}(t_f). \]

Since \( \mathbf{T}(t_f) \) is nonsingular, the rank of the Gramian is unchanged.

LTV controllability and observability are finite-interval properties. Controllability is characterized by the rank of \( \mathbf{W}_c(t_0,t_f) \), while observability is characterized by the rank of \( \mathbf{W}_o(t_0,t_f) \). These Gramians depend on the state transition matrix and therefore capture how actuator and sensor directions evolve through time. Uniform complete versions of these properties are stronger concepts needed in advanced LTV observer, estimator, and adaptive-control theory.