In Chapter 7 we solved the homogeneous LTI system using the matrix exponential. In Chapter 8, Lesson 1, the state transition matrix was defined as the operator satisfying \( \mathbf{x}(t)=\boldsymbol{\Phi}(t)\mathbf{x}(0) \). In Lesson 2, we proved the semigroup and inverse properties. This lesson asks how to compute \( \boldsymbol{\Phi}(t) \) analytically when the state matrix has enough independent eigenvectors.

For a continuous-time LTI system,

\[ \dot{\mathbf{x} }(t)=\mathbf{A}\mathbf{x}(t),\qquad \mathbf{x}(0)=\mathbf{x}_0,\qquad \mathbf{A}\in\mathbb{R}^{n\times n}, \]

the state transition matrix is \( \boldsymbol{\Phi}(t)=e^{\mathbf{A}t} \). Eigen-decomposition computes this exponential by changing coordinates to modal coordinates, where the dynamics decouple into scalar first-order differential equations.

flowchart TD
  A["State matrix A"] --> B["Find eigenvectors V and eigenvalues Lambda"]
  B --> C["Change coordinates: x = V z"]
  C --> D["Modal dynamics: zdot = Lambda z"]
  D --> E["Scalar solutions: zi(t) = exp(lambda_i t) zi(0)"]
  E --> F["Transform back: x(t) = V exp(Lambda t) V^-1 x(0)"]
  F --> G["Phi(t) = V exp(Lambda t) V^-1"]
        

Suppose \( \mathbf{A} \) has \( n \) linearly independent eigenvectors \( \mathbf{v}_1,\dots,\mathbf{v}_n \) with eigenvalues \( \lambda_1,\dots,\lambda_n \). Define

\[ \mathbf{V}=\begin{bmatrix}\mathbf{v}_1 & \mathbf{v}_2 & \cdots & \mathbf{v}_n\end{bmatrix},\qquad \boldsymbol{\Lambda}=\operatorname{diag}(\lambda_1,\lambda_2,\dots,\lambda_n). \]

Since \( \mathbf{A}\mathbf{v}_i=\lambda_i\mathbf{v}_i \), the matrix form of all eigenvector equations is

\[ \mathbf{A}\mathbf{V}=\mathbf{V}\boldsymbol{\Lambda}. \]

If \( \det(\mathbf{V})\neq 0 \), then

\[ \mathbf{A}=\mathbf{V}\boldsymbol{\Lambda}\mathbf{V}^{-1}. \]

This is the diagonalizable case. Distinct eigenvalues are sufficient for diagonalizability, but not necessary. Repeated eigenvalues can still lead to diagonalization if their eigenspaces contain enough independent eigenvectors. The defective case is deferred to Lesson 4, where Jordan chains produce polynomial factors multiplying exponentials.

The matrix exponential is defined by the absolutely convergent power series

\[ e^{\mathbf{A}t}=\sum_{k=0}^{\infty}\frac{(\mathbf{A}t)^k}{k!}. \]

If \( \mathbf{A}=\mathbf{V}\boldsymbol{\Lambda}\mathbf{V}^{-1} \), then by induction,

\[ \mathbf{A}^k=\mathbf{V}\boldsymbol{\Lambda}^k\mathbf{V}^{-1}, \qquad k=0,1,2,\dots . \]

Substituting into the exponential series gives

\[ \begin{aligned} e^{\mathbf{A}t} &=\sum_{k=0}^{\infty}\frac{t^k}{k!} \mathbf{V}\boldsymbol{\Lambda}^k\mathbf{V}^{-1} \\ &=\mathbf{V}\left(\sum_{k=0}^{\infty} \frac{(\boldsymbol{\Lambda}t)^k}{k!}\right)\mathbf{V}^{-1} \\ &=\mathbf{V}e^{\boldsymbol{\Lambda}t}\mathbf{V}^{-1} . \end{aligned} \]

Since \( \boldsymbol{\Lambda} \) is diagonal, its exponential is obtained by exponentiating only the diagonal entries:

\[ e^{\boldsymbol{\Lambda}t}= \operatorname{diag}\left(e^{\lambda_1 t},e^{\lambda_2 t}, \dots,e^{\lambda_n t}\right). \]

Therefore, for a diagonalizable state matrix,

\[ \boxed{\boldsymbol{\Phi}(t)=e^{\mathbf{A}t} =\mathbf{V}\operatorname{diag}\left(e^{\lambda_1 t},\dots, e^{\lambda_n t}\right)\mathbf{V}^{-1} }. \]

Let \( \mathbf{x}=\mathbf{V}\mathbf{z} \). Since \( \mathbf{V} \) is constant and invertible,

\[ \dot{\mathbf{x} }=\mathbf{V}\dot{\mathbf{z} }. \]

Substituting into \( \dot{\mathbf{x} }=\mathbf{A}\mathbf{x} \) yields

\[ \mathbf{V}\dot{\mathbf{z} }= \mathbf{A}\mathbf{V}\mathbf{z} =\mathbf{V}\boldsymbol{\Lambda}\mathbf{z}. \]

Multiplying by \( \mathbf{V}^{-1} \) gives

\[ \dot{\mathbf{z} }=\boldsymbol{\Lambda}\mathbf{z}. \]

Thus each modal coordinate satisfies an independent scalar equation:

\[ \dot{z}_i=\lambda_i z_i,\qquad z_i(t)=e^{\lambda_i t}z_i(0),\qquad i=1,\dots,n. \]

Returning to physical coordinates gives

\[ \mathbf{x}(t)=\mathbf{V}\mathbf{z}(t) =\mathbf{V}e^{\boldsymbol{\Lambda}t}\mathbf{z}(0) =\mathbf{V}e^{\boldsymbol{\Lambda}t}\mathbf{V}^{-1}\mathbf{x}(0). \]

This modal interpretation is fundamental in modern control because each eigenvalue determines a natural time behavior, while each eigenvector determines the state-space direction associated with that behavior.

If \( \lambda_i\in\mathbb{R} \), the mode \( e^{\lambda_i t} \) is purely exponential. Negative eigenvalues decay, positive eigenvalues grow, and zero eigenvalues remain constant in the homogeneous response.

If a real matrix \( \mathbf{A} \) has a complex eigenvalue \( \lambda=\alpha+j\beta \), the conjugate \( \bar{\lambda}=\alpha-j\beta \) is also an eigenvalue. The modal exponential is

\[ e^{(\alpha+j\beta)t}=e^{\alpha t}\left(\cos(\beta t) +j\sin(\beta t)\right). \]

Therefore complex eigenvalues represent oscillatory modes whose envelope is controlled by \( e^{\alpha t} \). The real state response is obtained by combining conjugate modal components so that imaginary terms cancel.

Repeated eigenvalues are not automatically problematic. If a repeated eigenvalue has enough independent eigenvectors, the same diagonal formula applies. If not, the matrix is defective and the Jordan-form computation in the next lesson is required.

flowchart TD
  S["Eigenvalue type"] --> R["Real lambda"]
  S --> C["Complex pair alpha +/- j beta"]
  S --> REP["Repeated lambda"]
  R --> R1["Mode: exp(lambda t)"]
  C --> C1["Mode: exp(alpha t) times \noscillation"]
  REP --> Q["Enough independent \neigenvectors?"]
  Q -->|yes| D["Use diagonal formula"]
  Q -->|no| J["Use Jordan method \nin next lesson"]
        

Consider the upper triangular state matrix

\[ \mathbf{A}= \begin{bmatrix} -1 & 2 \\ 0 & -2 \end{bmatrix}. \]

Its eigenvalues are the diagonal entries: \( \lambda_1=-1 \) and \( \lambda_2=-2 \). For \( \lambda_1=-1 \),

\[ (\mathbf{A}+\mathbf{I})\mathbf{v}_1=\mathbf{0} \quad\Rightarrow\quad \begin{bmatrix}0&2\\0&-1\end{bmatrix} \begin{bmatrix}v_{11}\\v_{21}\end{bmatrix}=\mathbf{0}, \quad \mathbf{v}_1=\begin{bmatrix}1\\0\end{bmatrix}. \]

For \( \lambda_2=-2 \),

\[ (\mathbf{A}+2\mathbf{I})\mathbf{v}_2=\mathbf{0} \quad\Rightarrow\quad \begin{bmatrix}1&2\\0&0\end{bmatrix} \begin{bmatrix}v_{12}\\v_{22}\end{bmatrix}=\mathbf{0}, \quad \mathbf{v}_2=\begin{bmatrix}-2\\1\end{bmatrix}. \]

Hence

\[ \mathbf{V}= \begin{bmatrix}1&-2\\0&1\end{bmatrix},\qquad \boldsymbol{\Lambda}= \begin{bmatrix}-1&0\\0&-2\end{bmatrix},\qquad \mathbf{V}^{-1}= \begin{bmatrix}1&2\\0&1\end{bmatrix}. \]

Therefore,

\[ \begin{aligned} \boldsymbol{\Phi}(t) &=\mathbf{V} \begin{bmatrix}e^{-t}&0\\0&e^{-2t}\end{bmatrix} \mathbf{V}^{-1} \\ &= \begin{bmatrix} e^{-t} & 2e^{-t}-2e^{-2t} \\ 0 & e^{-2t} \end{bmatrix} . \end{aligned} \]

The off-diagonal term appears because the physical state variables are coupled, even though the modal coordinates are decoupled.

The formula \( \mathbf{V}e^{\boldsymbol{\Lambda}t}\mathbf{V}^{-1} \) is mathematically exact for diagonalizable matrices, but numerical reliability depends strongly on the conditioning of \( \mathbf{V} \). If eigenvectors are nearly linearly dependent, small floating-point errors in \( \mathbf{V} \) or \( \mathbf{V}^{-1} \) can be amplified.

\[ \kappa(\mathbf{V})=\lVert\mathbf{V}\rVert \lVert\mathbf{V}^{-1}\rVert. \]

A large \( \kappa(\mathbf{V}) \) indicates that the modal basis is numerically sensitive. In professional numerical work, robust algorithms such as scaling-and-squaring with Padé approximation or Schur-based methods are often preferred for direct computation of \( e^{\mathbf{A}t} \). The eigen-decomposition method remains essential for theory, interpretation, and hand calculation of modal behavior.

In code, avoid explicitly forming the inverse when possible. Instead of computing \( \mathbf{V}^{-1}\mathbf{x}_0 \) by inversion, solve the linear system \( \mathbf{V}\mathbf{z}_0=\mathbf{x}_0 \).

The Python implementation uses numpy and scipy.linalg. It computes the eigen-decomposition, checks whether the eigenvector matrix is full rank, warns about conditioning, and compares the result against scipy.linalg.expm.

"""
Chapter8_Lesson3.py

Computing the state transition matrix Phi(t) = exp(A t) via eigen-decomposition.

Dependencies:
    pip install numpy scipy

This script demonstrates:
1. diagonalization A = V Lambda V^{-1},
2. Phi(t) = V exp(Lambda t) V^{-1},
3. comparison with scipy.linalg.expm,
4. modal coordinates z = V^{-1} x.
"""

import numpy as np
from scipy.linalg import expm, eig, solve


def phi_via_eigendecomposition(A: np.ndarray, t: float, cond_tol: float = 1e10) -> np.ndarray:
    """
    Compute Phi(t) = exp(A t) from A = V Lambda V^{-1}.

    The method is reliable only when A has a complete eigenvector basis and V
    is not severely ill-conditioned.
    """
    A = np.asarray(A, dtype=float)
    eigenvalues, V = eig(A)
    if np.linalg.matrix_rank(V) < A.shape[0]:
        raise ValueError("A is not diagonalizable: eigenvector matrix V is rank deficient.")

    cond_V = np.linalg.cond(V)
    if cond_V > cond_tol:
        print(f"Warning: eigenvector matrix is ill-conditioned, cond(V)={cond_V:.3e}")

    exp_Lambda_t = np.diag(np.exp(eigenvalues * t))

    # Prefer solve over explicit inverse: V exp(Dt) V^{-1} = V exp(Dt) solve(V, I)
    Phi = V @ exp_Lambda_t @ np.linalg.inv(V)

    return np.real_if_close(Phi, tol=1000)


def modal_coordinates(A: np.ndarray, x0: np.ndarray, t: float):
    """
    Return x(t) and modal coordinates z(t) for xdot = A x.
    """
    eigenvalues, V = eig(A)
    z0 = solve(V, x0.astype(complex))
    zt = np.exp(eigenvalues * t) * z0
    xt = V @ zt
    return np.real_if_close(xt), np.real_if_close(zt), eigenvalues


def main():
    A = np.array([
        [-1.0,  2.0,  0.0],
        [ 0.0, -2.0,  0.0],
        [ 0.0,  0.0, -0.5],
    ])

    t = 2.0
    Phi_eig = phi_via_eigendecomposition(A, t)
    Phi_expm = expm(A * t)

    print("A =")
    print(A)
    print("\nPhi(t) via eigen-decomposition =")
    print(Phi_eig)
    print("\nPhi(t) via scipy.linalg.expm =")
    print(Phi_expm)
    print("\nFrobenius error =")
    print(np.linalg.norm(Phi_eig - Phi_expm, ord="fro"))

    x0 = np.array([1.0, -1.0, 2.0])
    xt, zt, lam = modal_coordinates(A, x0, t)

    print("\nEigenvalues =")
    print(lam)
    print("\nInitial state x0 =")
    print(x0)
    print("\nState x(t) = Phi(t) x0 =")
    print(xt)
    print("\nModal coordinates z(t) = exp(lambda_i t) z_i(0) =")
    print(zt)


if __name__ == "__main__":
    main()

The C++ implementation uses the Eigen library. Eigen is widely used in robotics, control, optimization, and embedded scientific computing.

/*
Chapter8_Lesson3.cpp

Computing Phi(t) = exp(A t) via eigen-decomposition in C++.

Dependency:
    Eigen 3
Compile example:
    g++ -std=c++17 Chapter8_Lesson3.cpp -I /path/to/eigen -O2 -o Chapter8_Lesson3

This implementation uses Eigen::EigenSolver. It assumes A is diagonalizable.
For production-grade matrix exponentials, compare against matrix-functions
modules or specialized numerical linear algebra libraries.
*/

#include <Eigen/Dense>
#include <Eigen/Eigenvalues>
#include <complex>
#include <iostream>
#include <stdexcept>

using Matrix = Eigen::MatrixXd;
using ComplexMatrix = Eigen::MatrixXcd;

ComplexMatrix phiViaEigendecomposition(const Matrix& A, double t, double condTol = 1.0e10) {
    Eigen::EigenSolver<Matrix> solver(A);
    if (solver.info() != Eigen::Success) {
        throw std::runtime_error("Eigen-decomposition failed.");
    }

    ComplexMatrix V = solver.eigenvectors();
    Eigen::VectorXcd lambda = solver.eigenvalues();

    Eigen::FullPivLU<ComplexMatrix> lu(V);
    if (lu.rank() < A.rows()) {
        throw std::runtime_error("A is not diagonalizable: eigenvector matrix is rank deficient.");
    }

    double condEstimate = V.norm() * V.inverse().norm();
    if (condEstimate > condTol) {
        std::cerr << "Warning: eigenvector matrix may be ill-conditioned; estimate = "
                  << condEstimate << std::endl;
    }

    ComplexMatrix expLambdaT = ComplexMatrix::Zero(A.rows(), A.cols());
    for (int i = 0; i < lambda.size(); ++i) {
        expLambdaT(i, i) = std::exp(lambda(i) * t);
    }

    return V * expLambdaT * V.inverse();
}

int main() {
    Matrix A(3, 3);
    A << -1.0,  2.0,  0.0,
          0.0, -2.0,  0.0,
          0.0,  0.0, -0.5;

    double t = 2.0;

    try {
        ComplexMatrix Phi = phiViaEigendecomposition(A, t);

        std::cout << "A =\n" << A << "\n\n";
        std::cout << "Phi(t) via eigen-decomposition =\n" << Phi << "\n\n";

        Eigen::VectorXcd x0(3);
        x0 << 1.0, -1.0, 2.0;
        Eigen::VectorXcd xt = Phi * x0;

        std::cout << "x0 =\n" << x0 << "\n\n";
        std::cout << "x(t) = Phi(t) x0 =\n" << xt << "\n";
    } catch (const std::exception& ex) {
        std::cerr << "Error: " << ex.what() << std::endl;
        return 1;
    }

    return 0;
}

The Java implementation uses Apache Commons Math. This simple version is intended for systems with real eigenvalues and a complete real eigenvector basis. Complex modes require a complex linear algebra package or real block-modal representation.

/*
Chapter8_Lesson3.java

Computing Phi(t) = exp(A t) via eigen-decomposition in Java.

Dependency:
    Apache Commons Math 3.6.1 or later

Compile example:
    javac -cp commons-math3-3.6.1.jar Chapter8_Lesson3.java
Run example:
    java -cp .:commons-math3-3.6.1.jar Chapter8_Lesson3

Windows classpath separator:
    java -cp .;commons-math3-3.6.1.jar Chapter8_Lesson3

This example is designed for matrices with real eigenvalues and a complete real
eigenvector basis. Complex modal pairs require a real block-modal treatment or
a complex linear algebra library.
*/

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.DecompositionSolver;
import org.apache.commons.math3.linear.EigenDecomposition;
import org.apache.commons.math3.linear.LUDecomposition;
import org.apache.commons.math3.linear.MatrixUtils;
import org.apache.commons.math3.linear.RealMatrix;
import org.apache.commons.math3.linear.RealVector;

public class Chapter8_Lesson3 {

    public static RealMatrix phiViaEigendecomposition(RealMatrix A, double t) {
        EigenDecomposition eig = new EigenDecomposition(A);

        RealMatrix V = eig.getV();
        RealMatrix D = eig.getD();

        int n = A.getRowDimension();

        for (int i = 0; i < n; i++) {
            if (Math.abs(eig.getImagEigenvalue(i)) > 1e-12) {
                throw new IllegalArgumentException(
                    "This simple example expects real eigenvalues. Use a complex library for complex modes."
                );
            }
        }

        DecompositionSolver solver = new LUDecomposition(V).getSolver();
        if (!solver.isNonSingular()) {
            throw new IllegalArgumentException("A is not diagonalizable: V is singular.");
        }

        RealMatrix expDt = MatrixUtils.createRealMatrix(n, n);
        for (int i = 0; i < n; i++) {
            expDt.setEntry(i, i, Math.exp(D.getEntry(i, i) * t));
        }

        RealMatrix Vinv = solver.getInverse();
        return V.multiply(expDt).multiply(Vinv);
    }

    public static void printMatrix(String title, RealMatrix M) {
        System.out.println(title);
        for (int i = 0; i < M.getRowDimension(); i++) {
            for (int j = 0; j < M.getColumnDimension(); j++) {
                System.out.printf("%12.6f ", M.getEntry(i, j));
            }
            System.out.println();
        }
        System.out.println();
    }

    public static void main(String[] args) {
        double[][] data = {
            {-1.0,  2.0,  0.0},
            { 0.0, -2.0,  0.0},
            { 0.0,  0.0, -0.5}
        };

        RealMatrix A = new Array2DRowRealMatrix(data);
        double t = 2.0;

        RealMatrix Phi = phiViaEigendecomposition(A, t);

        printMatrix("A =", A);
        printMatrix("Phi(t) via eigen-decomposition =", Phi);

        RealVector x0 = MatrixUtils.createRealVector(new double[] {1.0, -1.0, 2.0});
        RealVector xt = Phi.operate(x0);

        System.out.println("x(t) = Phi(t) x0 =");
        for (int i = 0; i < xt.getDimension(); i++) {
            System.out.printf("%12.6f%n", xt.getEntry(i));
        }
    }
}

MATLAB provides eig for eigen-decomposition and expm for robust matrix exponentials. In Simulink, the same educational function can be placed inside a MATLAB Function block, while production workflows should use validated numerical routines or precomputed modal data when the matrix is constant.

% Chapter8_Lesson3.m
%
% Computing the state transition matrix Phi(t) = expm(A*t) via eigen-decomposition.
%
% MATLAB functions used:
%   eig  - eigenvalues/eigenvectors
%   expm - robust built-in matrix exponential for comparison
%   cond - conditioning of eigenvector matrix
%
% Simulink note:
%   The helper function phi_via_eigendecomposition can be placed in a MATLAB
%   Function block for educational demonstrations. For real-time deployment,
%   precompute modal data or use validated numerical routines.

clear; clc;

A = [-1.0,  2.0,  0.0;
      0.0, -2.0,  0.0;
      0.0,  0.0, -0.5];

t = 2.0;

PhiEig = phi_via_eigendecomposition(A, t);
PhiExpm = expm(A * t);

disp('A =');
disp(A);

disp('Phi(t) via eigen-decomposition =');
disp(PhiEig);

disp('Phi(t) via expm(A*t) =');
disp(PhiExpm);

disp('Frobenius error =');
disp(norm(PhiEig - PhiExpm, 'fro'));

x0 = [1.0; -1.0; 2.0];
xt = PhiEig * x0;

disp('x(t) = Phi(t) x0 =');
disp(xt);

function Phi = phi_via_eigendecomposition(A, t)
    [V, D] = eig(A);

    if rank(V) < size(A, 1)
        error('A is not diagonalizable: eigenvector matrix V is rank deficient.');
    end

    c = cond(V);
    if c > 1e10
        warning('Eigenvector matrix is ill-conditioned: cond(V) = %g', c);
    end

    Phi = V * exp(D * t) / V;

    if isreal(A) && norm(imag(Phi), 'fro') < 1e-10
        Phi = real(Phi);
    end
end

Mathematica provides symbolic and numerical routines for Eigensystem and MatrixExp. The following notebook-style code compares the modal computation with the built-in matrix exponential.

(* ::Package:: *)

(* Chapter8_Lesson3.nb *)

(* Computing Phi(t) = MatrixExp[A t] via eigen-decomposition in Wolfram Mathematica. *)

ClearAll["Global`*"];

A = { {-1.0, 2.0, 0.0},
     { 0.0,-2.0, 0.0},
     { 0.0, 0.0,-0.5} };

t = 2.0;

{vals, vecsRows} = Eigensystem[A];
V = Transpose[vecsRows];

If[MatrixRank[V] < Length[A],
   Print["A is not diagonalizable: eigenvector matrix is rank deficient."],
   Dmat = DiagonalMatrix[vals];
   PhiEig = V . MatrixExp[Dmat t] . Inverse[V];
   PhiExact = MatrixExp[A t];

   Print["Eigenvalues = "];
   Print[vals];

   Print["Phi(t) via eigen-decomposition = "];
   Print[MatrixForm[Chop[PhiEig]]];

   Print["Phi(t) via MatrixExp[A t] = "];
   Print[MatrixForm[Chop[PhiExact]]];

   Print["Frobenius error = "];
   Print[Norm[PhiEig - PhiExact, "Frobenius"]];

   x0 = {1.0, -1.0, 2.0};
   xt = PhiEig . x0;

   Print["x(t) = Phi(t) x0 = "];
   Print[Chop[xt]];
];

Problem 1 (Diagonal STM Formula): Let \( \mathbf{A}=\operatorname{diag}(a_1,a_2,\dots,a_n) \). Compute \( \boldsymbol{\Phi}(t) \).

Solution: Since \( \mathbf{A} \) is already diagonal, the eigenvector matrix is \( \mathbf{V}=\mathbf{I} \). Therefore,

\[ \boldsymbol{\Phi}(t)=e^{\mathbf{A}t}= \operatorname{diag}(e^{a_1t},e^{a_2t},\dots,e^{a_nt}). \]

Problem 2 (Modal Coordinates): Suppose \( \mathbf{A}=\mathbf{V}\boldsymbol{\Lambda}\mathbf{V}^{-1} \) and \( \mathbf{x}(0)=\mathbf{x}_0 \). Show that the initial modal coordinates are \( \mathbf{z}(0)=\mathbf{V}^{-1}\mathbf{x}_0 \) and that \( z_i(t)=e^{\lambda_i t}z_i(0) \).

Solution: By the coordinate change \( \mathbf{x}=\mathbf{V}\mathbf{z} \), at \( t=0 \) we have \( \mathbf{x}_0=\mathbf{V}\mathbf{z}(0) \). Multiplying by \( \mathbf{V}^{-1} \) gives \( \mathbf{z}(0)=\mathbf{V}^{-1}\mathbf{x}_0 \). Since \( \dot{\mathbf{z} }=\boldsymbol{\Lambda}\mathbf{z} \), the \( i \)-th scalar equation is \( \dot{z}_i=\lambda_i z_i \), whose solution is \( z_i(t)=e^{\lambda_i t}z_i(0) \).

Problem 3 (Two-Dimensional Example): For \( \mathbf{A}=\begin{bmatrix}2&0\\0&-3\end{bmatrix} \), compute \( \boldsymbol{\Phi}(t) \) and determine whether each mode grows or decays.

Solution:

\[ \boldsymbol{\Phi}(t)= \begin{bmatrix}e^{2t}&0\\0&e^{-3t}\end{bmatrix}. \]

The first mode grows exponentially because \( \lambda_1=2 \). The second mode decays exponentially because \( \lambda_2=-3 \).

Problem 4 (Complex Mode Interpretation): A real second-order system has eigenvalues \( -2+j5 \) and \( -2-j5 \). Describe the qualitative homogeneous response.

Solution: The real part \( -2 \) creates the decaying envelope \( e^{-2t} \). The imaginary part \( 5 \) creates sinusoidal oscillation with angular frequency \( 5 \) rad/s. Therefore the response is a decaying oscillation.

Problem 5 (Checking Diagonalizability): Explain why the eigen-decomposition formula cannot be used directly when \( \mathbf{V} \) is singular.

Solution: The formula requires \( \mathbf{A}=\mathbf{V}\boldsymbol{\Lambda}\mathbf{V}^{-1} \). If \( \mathbf{V} \) is singular, then \( \mathbf{V}^{-1} \) does not exist, and the transformation to independent modal coordinates is impossible. The correct approach is to use Jordan form or a numerical method such as Schur-based matrix exponential computation.

For a diagonalizable state matrix \( \mathbf{A} \), the state transition matrix can be computed by diagonalizing the dynamics: \( \boldsymbol{\Phi}(t)=\mathbf{V}e^{\boldsymbol{\Lambda}t}\mathbf{V}^{-1} \). In modal coordinates, the system separates into independent scalar equations. The method gives strong analytical insight into modes, oscillations, growth, decay, and physical coupling. Numerically, however, the method can be sensitive when the eigenvector matrix is ill-conditioned, motivating more robust algorithms in later lessons.