In Chapter 7 you learned that the homogeneous LTI state equation \( \dot{x}(t)=Ax(t) \) admits solutions determined uniquely by the initial condition \( x(t_0)=x_0 \). The state transition matrix is the linear operator that realizes this mapping: it is the matrix \( \Phi(t,t_0) \) satisfying \( x(t)=\Phi(t,t_0)\,x_0 \).

flowchart TD
  A["State ODE: xdot = A x"] --> B["Choose initial time t0 and state x0"]
  B --> C["Solve initial-value problem"]
  C --> D["State at time t: x(t)"]
  D --> E["Define linear map: x(t) = Phi(t,t0) x0"]
  E --> F["Phi solves: d/dt Phi = A Phi,  Phi(t0,t0) = I"]
        

When a fixed reference time \( t_0=0 \) is used frequently, it is common to abbreviate \( \Phi(t) := \Phi(t,0) \). In this lesson we develop the two-time definition \( \Phi(t,t_0) \) and then specialize to \( \Phi(t) \).

Consider the homogeneous LTI system in \( \mathbb{R}^n \):

\[ \dot{x}(t) = A x(t), \qquad x(t_0)=x_0, \quad A \in \mathbb{R}^{n\times n}. \]

Existence and uniqueness (from standard linear ODE theory) implies: for each \( x_0 \) there exists a unique trajectory \( x(\cdot) \). The crucial observation is that the mapping \( x_0 \mapsto x(t) \) is linear, hence representable by a matrix.

Theorem 2.1 (Linearity of the State-Propagation Map). Fix \( t \) and \( t_0 \). Define \( \mathcal{T}_{t,t_0}:\mathbb{R}^n \to \mathbb{R}^n \) by \( \mathcal{T}_{t,t_0}(x_0)=x(t) \), where \( x(\cdot) \) solves the IVP above. Then \( \mathcal{T}_{t,t_0} \) is linear.

Proof. Let \( x_a(\cdot) \) solve with \( x_a(t_0)=a \) and \( x_b(\cdot) \) solve with \( x_b(t_0)=b \). For scalars \( \alpha,\beta \), define \( z(t)=\alpha x_a(t)+\beta x_b(t) \). Then \( \dot{z}(t)=\alpha \dot{x}_a(t)+\beta \dot{x}_b(t)=\alpha A x_a(t)+\beta A x_b(t)=A z(t) \) and \( z(t_0)=\alpha a+\beta b \). By uniqueness, \( z(\cdot) \) is precisely the solution corresponding to initial condition \( \alpha a+\beta b \). Hence \( \mathcal{T}_{t,t_0}(\alpha a+\beta b)=\alpha \mathcal{T}_{t,t_0}(a)+\beta \mathcal{T}_{t,t_0}(b) \). ∎

Therefore there exists a unique matrix \( \Phi(t,t_0) \) such that

\[ x(t) = \Phi(t,t_0)\,x_0 \quad \text{for all } x_0 \in \mathbb{R}^n. \]

This motivates the core definition.

Definition 2.2 (State Transition Matrix). The state transition matrix for \( \dot{x}(t)=Ax(t) \) is the matrix function \( \Phi(t,t_0) \in \mathbb{R}^{n\times n} \) defined by the requirement that for every initial state \( x_0 \), the solution satisfies \( x(t)=\Phi(t,t_0)x_0 \).

Let \( e_1,\dots,e_n \) denote the standard basis vectors in \( \mathbb{R}^n \). For each \( i \), let \( x_i(t) \) be the unique solution of \( \dot{x}=Ax \) with initial condition \( x_i(t_0)=e_i \). Form the matrix

\[ X(t) := \begin{bmatrix} x_1(t) & x_2(t) & \cdots & x_n(t) \end{bmatrix}. \]

Then \( X(t_0)=I \) and, differentiating column-wise,

\[ \dot{X}(t) = \begin{bmatrix} \dot{x}_1(t) & \cdots & \dot{x}_n(t) \end{bmatrix} = \begin{bmatrix} A x_1(t) & \cdots & A x_n(t) \end{bmatrix} = A X(t). \]

By construction, for any \( x_0=\sum_{i=1}^n \alpha_i e_i \), linearity gives \( x(t)=\sum_{i=1}^n \alpha_i x_i(t)=X(t)\,x_0 \). Hence \( \Phi(t,t_0)=X(t) \).

Proposition 3.1 (Defining IVP for Φ). The state transition matrix is the unique matrix function satisfying

\[ \dot{\Phi}(t,t_0)=A\,\Phi(t,t_0), \qquad \Phi(t_0,t_0)=I. \]

Proof. Existence follows from the construction above (take \( \Phi=X \)). For uniqueness: if \( \Psi(t) \) satisfies the same matrix IVP, then for every \( x_0 \) the vector \( \Psi(t)x_0 \) solves \( \dot{x}=Ax \) with initial condition \( x(t_0)=x_0 \). By uniqueness of the vector IVP, \( \Psi(t)x_0=\Phi(t,t_0)x_0 \) for all \( x_0 \), hence \( \Psi(t)=\Phi(t,t_0) \). ∎

The definition above is the operational one used throughout modern control: Φ is not “assumed,” it is uniquely determined as the matrix solution of a first-order linear matrix differential equation.

Recall from Chapter 3 the matrix exponential definition (convergent for all finite matrices):

\[ e^{M} := \sum_{k=0}^{\infty}\frac{M^k}{k!}. \]

Set \( M=A(t-t_0) \). The following theorem links the STM definition to \( e^{A(t-t_0)} \).

Theorem 4.1. The matrix function \( \Phi(t,t_0)=e^{A(t-t_0)} \) satisfies

\[ \dot{\Phi}(t,t_0)=A\,\Phi(t,t_0), \qquad \Phi(t_0,t_0)=I, \]

and therefore equals the state transition matrix.

Proof. Define \( \Phi(t,t_0)=\sum_{k=0}^{\infty}\frac{(A(t-t_0))^k}{k!} \). First, at \( t=t_0 \) we obtain \( \Phi(t_0,t_0)=\sum_{k=0}^{\infty}\frac{0^k A^k}{k!}=I \).

Differentiate term-by-term (justified since the series converges uniformly on any bounded interval in \( t \)):

\[ \frac{d}{dt}\Phi(t,t_0) = \frac{d}{dt}\left(\sum_{k=0}^{\infty}\frac{A^k (t-t_0)^k}{k!}\right) = \sum_{k=1}^{\infty}\frac{A^k\,k\,(t-t_0)^{k-1} }{k!} = \sum_{k=1}^{\infty}\frac{A^k (t-t_0)^{k-1} }{(k-1)!}. \]

Re-index with \( j=k-1 \):

\[ \frac{d}{dt}\Phi(t,t_0) = \sum_{j=0}^{\infty}\frac{A^{j+1}(t-t_0)^j}{j!} = A \sum_{j=0}^{\infty}\frac{A^{j}(t-t_0)^j}{j!} = A \Phi(t,t_0). \]

Thus \( e^{A(t-t_0)} \) satisfies the defining matrix IVP of Proposition 3.1. By uniqueness, it equals the STM. ∎

Consequently, for the common shorthand \( t_0=0 \), we obtain the canonical identity:

\[ \Phi(t) = e^{At}. \]

Using the series definition, for a small time increment \( h \) we have

\[ \Phi(t_0+h,t_0)=e^{Ah} = I + Ah + \frac{(Ah)^2}{2!} + \cdots. \]

Hence the first-order approximation is \( \Phi(t_0+h,t_0) \approx I + Ah \), meaning the state update is locally

\[ x(t_0+h)=\Phi(t_0+h,t_0)x(t_0) \approx \left(I+Ah\right)x(t_0) = x(t_0) + h\,A x(t_0), \]

which is consistent with the differential equation \( \dot{x}(t_0)=Ax(t_0) \). This “infinitesimal” viewpoint is foundational for numerical simulation methods (Euler and beyond), which you will revisit in Chapter 7’s numerical simulation lesson.

While Chapters 8.3–8.5 will cover computation methods in detail, it is useful to preview the standard workflow: (i) define \( A \), (ii) choose an exponential computation method, (iii) obtain \( \Phi(t,t_0) \), and (iv) propagate \( x(t)=\Phi(t,t_0)x_0 \).

flowchart TD
  A["Given A and times (t,t0)"] --> B["Compute tau = t - t0"]
  B --> C["Choose method"]
  C --> D1["Library expm (preferred)"]
  C --> D2["Series (small tau)"]
  C --> D3["Eigen / Jordan (symbolic / analytic)"]
  D1 --> E["Phi = exp(A*tau)"]
  D2 --> E
  D3 --> E
  E --> F["Propagate: x(t) = Phi x0"]
        

In Python, the standard numerical route is scipy.linalg.expm. The script below also verifies \( x(t)=\Phi(t,t_0)x_0 \) against numerical integration of \( \dot{x}=Ax \). Relevant libraries for modern control workflows include numpy, scipy, and (later) control for state-space objects and simulation.

Chapter8_Lesson1.py

# Chapter8_Lesson1.py
# Modern Control — Chapter 8, Lesson 1: Definition of the State Transition Matrix
#
# Requires: numpy, scipy, matplotlib (optional)
#   pip install numpy scipy matplotlib
#
# This script:
#   1) Computes Phi(t,t0) = expm(A*(t-t0))
#   2) Propagates x(t) = Phi(t,t0) x0
#   3) Verifies against numerical integration of xdot = A x

import numpy as np
from scipy.linalg import expm, norm
from scipy.integrate import solve_ivp

def state_transition_matrix(A: np.ndarray, t: float, t0: float = 0.0) -> np.ndarray:
    """Phi(t,t0) for LTI xdot = A x."""
    return expm(A * (t - t0))

def propagate_state(A: np.ndarray, x0: np.ndarray, t: float, t0: float = 0.0) -> np.ndarray:
    Phi = state_transition_matrix(A, t, t0)
    return Phi @ x0

def integrate_state(A: np.ndarray, x0: np.ndarray, t: float, t0: float = 0.0) -> np.ndarray:
    """Numerical integration for comparison."""
    def f(_tau, x):
        return (A @ x)

    sol = solve_ivp(f, (t0, t), x0, method="RK45", rtol=1e-10, atol=1e-12)
    return sol.y[:, -1]

def main():
    # Example A (stable 2x2) and initial condition
    A = np.array([[0.0, 1.0],
                  [-2.0, -3.0]])
    x0 = np.array([1.0, -0.5])

    t0 = 0.0
    t  = 1.25

    Phi = state_transition_matrix(A, t, t0)
    x_analytic = propagate_state(A, x0, t, t0)
    x_numeric  = integrate_state(A, x0, t, t0)

    print("A =\n", A)
    print("t0 =", t0, "t =", t)
    print("Phi(t,t0) =\n", Phi)
    print("x_analytic =", x_analytic)
    print("x_numeric  =", x_numeric)
    print("||x_analytic - x_numeric||_2 =", norm(x_analytic - x_numeric, 2))

    # Optional: check the defining ODE for Phi(t,t0): d/dt Phi = A Phi
    dt = 1e-6
    Phi_t   = state_transition_matrix(A, t, t0)
    Phi_tdt = state_transition_matrix(A, t + dt, t0)
    Phi_dot_fd = (Phi_tdt - Phi_t) / dt
    residual = Phi_dot_fd - A @ Phi_t
    print("||Phi_dot_fd - A Phi||_F =", norm(residual, ord="fro"))

if __name__ == "__main__":
    main()

In C++, a common control-oriented linear algebra choice is Eigen. Robust matrix exponential algorithms are typically provided by specialized routines; however, the definition itself suggests a correct “from scratch” baseline: \( e^{M}=\sum_{k=0}^{\infty}\frac{M^k}{k!} \). The following implementation truncates this series.

Chapter8_Lesson1.cpp

// Chapter8_Lesson1.cpp
// Modern Control — Chapter 8, Lesson 1: Definition of the State Transition Matrix
//
// This example computes Phi(t,t0) ≈ exp(A*(t-t0)) using a truncated power series.
// For production, prefer a robust library implementation (e.g., Eigen's MatrixFunctions).
//
// Dependencies (recommended): Eigen (header-only)
// Compile (example):
//   g++ -O2 -std=c++17 Chapter8_Lesson1.cpp -I /path/to/eigen -o Chapter8_Lesson1
//
// Run:
//   ./Chapter8_Lesson1

#include <iostream>
#include <iomanip>
#include <Eigen/Dense>

static Eigen::MatrixXd expm_series(const Eigen::MatrixXd& A, double tau, int terms) {
    const int n = static_cast<int>(A.rows());
    Eigen::MatrixXd M = A * tau;
    Eigen::MatrixXd term = Eigen::MatrixXd::Identity(n, n);
    Eigen::MatrixXd sum  = Eigen::MatrixXd::Identity(n, n);

    for (int k = 1; k <= terms; ++k) {
        term = (term * M) / static_cast<double>(k);
        sum  = sum + term;
    }
    return sum;
}

int main() {
    Eigen::Matrix2d A;
    A << 0.0, 1.0,
        -2.0, -3.0;

    Eigen::Vector2d x0;
    x0 << 1.0, -0.5;

    double t0 = 0.0;
    double t  = 1.25;
    double tau = t - t0;

    // Series truncation (increase for higher accuracy)
    int terms = 30;
    Eigen::Matrix2d Phi = expm_series(A, tau, terms);

    Eigen::Vector2d x = Phi * x0;

    std::cout << std::setprecision(12);
    std::cout << "A =\n" << A << "\n\n";
    std::cout << "tau = t - t0 = " << tau << "\n\n";
    std::cout << "Phi(t,t0) approx (series, terms=" << terms << ") =\n" << Phi << "\n\n";
    std::cout << "x(t) = Phi x0 =\n" << x << "\n";

    // Consistency check: finite-difference derivative of Phi vs A*Phi
    double dt = 1e-6;
    Eigen::Matrix2d Phi_t   = expm_series(A, tau, terms);
    Eigen::Matrix2d Phi_tdt = expm_series(A, tau + dt, terms);
    Eigen::Matrix2d Phi_dot_fd = (Phi_tdt - Phi_t) / dt;
    Eigen::Matrix2d residual = Phi_dot_fd - (A * Phi_t);
    std::cout << "\n||Phi_dot_fd - A Phi||_F = " << residual.norm() << "\n";

    return 0;
}

In Java, a practical linear algebra choice is Apache Commons Math (RealMatrix). The script below implements the same truncated-series definition of \( e^{A(t-t_0)} \). This is mathematically faithful to the definition of Φ, while later lessons will discuss numerical conditioning and preferred algorithms.

Chapter8_Lesson1.java

// Chapter8_Lesson1.java
// Modern Control — Chapter 8, Lesson 1: Definition of the State Transition Matrix
//
// This example computes Phi(t,t0) ≈ exp(A*(t-t0)) using a truncated power series,
// implemented with Apache Commons Math matrices.
//
// Maven dependency:
//   <dependency>
//     <groupId>org.apache.commons</groupId>
//     <artifactId>commons-math3</artifactId>
//     <version>3.6.1</version>
//   </dependency>
//
// Compile (with commons-math3 on classpath):
//   javac -cp commons-math3-3.6.1.jar Chapter8_Lesson1.java
// Run:
//   java -cp .:commons-math3-3.6.1.jar Chapter8_Lesson1

import org.apache.commons.math3.linear.MatrixUtils;
import org.apache.commons.math3.linear.RealMatrix;

public class Chapter8_Lesson1 {

    public static RealMatrix expmSeries(RealMatrix A, double tau, int terms) {
        int n = A.getRowDimension();
        RealMatrix M = A.scalarMultiply(tau);
        RealMatrix term = MatrixUtils.createRealIdentityMatrix(n);
        RealMatrix sum  = MatrixUtils.createRealIdentityMatrix(n);

        for (int k = 1; k <= terms; k++) {
            term = term.multiply(M).scalarMultiply(1.0 / ((double) k));
            sum  = sum.add(term);
        }
        return sum;
    }

    public static void main(String[] args) {
        double[][] Adata = new double[][]{
            {0.0,  1.0},
            {-2.0, -3.0}
        };
        RealMatrix A = MatrixUtils.createRealMatrix(Adata);

        double[] x0 = new double[]{1.0, -0.5};

        double t0 = 0.0;
        double t  = 1.25;
        double tau = t - t0;

        int terms = 30;
        RealMatrix Phi = expmSeries(A, tau, terms);

        double[] x = Phi.operate(x0);

        System.out.println("tau = t - t0 = " + tau);
        System.out.println("Phi(t,t0) approx (series, terms=" + terms + "):");
        System.out.println(Phi.toString());
        System.out.println("x(t) = Phi x0:");
        System.out.println("[" + x[0] + ", " + x[1] + "]");

        // Finite-difference derivative check: Phi_dot approx vs A*Phi
        double dt = 1e-6;
        RealMatrix Phi_t   = expmSeries(A, tau, terms);
        RealMatrix Phi_tdt = expmSeries(A, tau + dt, terms);
        RealMatrix Phi_dot_fd = Phi_tdt.subtract(Phi_t).scalarMultiply(1.0 / dt);
        RealMatrix residual = Phi_dot_fd.subtract(A.multiply(Phi_t));
        double fro = residual.getFrobeniusNorm();
        System.out.println("||Phi_dot_fd - A Phi||_F = " + fro);
    }
}

MATLAB provides a mature matrix exponential expm. The script below computes \( \Phi(t,t_0)=e^{A(t-t_0)} \), propagates \( x(t) \), and verifies via ode45. It also includes an optional programmatic Simulink model that simulates \( \dot{x}=Ax \) with zero input.

Chapter8_Lesson1.m

% Chapter8_Lesson1.m
% Modern Control — Chapter 8, Lesson 1: Definition of the State Transition Matrix
%
% This script:
%   1) Computes Phi(t,t0) = expm(A*(t-t0))
%   2) Propagates x(t) = Phi x0 for xdot = A x
%   3) Verifies against numerical integration (ode45)
%   4) (Optional) Builds a simple Simulink model programmatically and simulates it
%
% Requirements:
%   - MATLAB base (expm, ode45)
%   - For ss/initial: Control System Toolbox (optional)
%   - For Simulink portion: Simulink (optional)

clear; clc;

A  = [0 1; -2 -3];
x0 = [1; -0.5];

t0 = 0.0;
t1 = 1.25;

% Analytic STM and state propagation
Phi = expm(A*(t1 - t0));
x_analytic = Phi*x0;

fprintf('A =\n'); disp(A);
fprintf('Phi(t1,t0) =\n'); disp(Phi);
fprintf('x_analytic =\n'); disp(x_analytic);

% Numerical verification using ode45
f = @(t,x) A*x;
opts = odeset('RelTol',1e-10,'AbsTol',1e-12);
[tt,xx] = ode45(f, [t0 t1], x0, opts);
x_numeric = xx(end,:).';
fprintf('x_numeric =\n'); disp(x_numeric);
fprintf('||x_analytic - x_numeric||_2 = %.3e\n', norm(x_analytic - x_numeric, 2));

% Optional: build and simulate a simple Simulink model (requires Simulink)
% The model simulates xdot = A x with zero input, outputting x to workspace.
try
    mdl = 'Chapter8_Lesson1_STM_Model';
    if bdIsLoaded(mdl); close_system(mdl, 0); end
    new_system(mdl); open_system(mdl);

    add_block('simulink/Sources/Constant', [mdl '/u'], 'Value', '0');
    add_block('simulink/Continuous/State-Space', [mdl '/Plant']);
    add_block('simulink/Sinks/To Workspace', [mdl '/x_out'], 'VariableName', 'x_sim', 'SaveFormat', 'Array');

    set_param([mdl '/Plant'], 'A', mat2str(A), 'B', mat2str([0;0]), 'C', 'eye(2)', 'D', '0', 'X0', mat2str(x0));
    set_param(mdl, 'StopTime', num2str(t1));

    add_line(mdl, 'u/1', 'Plant/1');
    add_line(mdl, 'Plant/1', 'x_out/1');

    sim(mdl);

    % x_sim is an array: [t, x1, x2]
    x_end = x_sim(end, 2:3).';
    fprintf('x_simulink(end) =\n'); disp(x_end);
    fprintf('||x_simulink(end) - x_analytic||_2 = %.3e\n', norm(x_end - x_analytic, 2));

catch ME
    fprintf('\n[Simulink portion skipped] %s\n', ME.message);
end

Mathematica provides MatrixExp, which is particularly convenient for symbolic checks of the defining equation \( \dot{\Phi}=A\Phi \). The code below computes Φ, checks the matrix ODE, and compares with a numerical IVP solve.

Chapter8_Lesson1.nb

(* Chapter8_Lesson1.nb
   Modern Control — Chapter 8, Lesson 1: Definition of the State Transition Matrix

   Note: This file is provided as Wolfram Language code in a .nb container.
   You may open it as text, or paste its contents into a Mathematica notebook.
*)

ClearAll["Global`*"];

A  = { {0, 1}, {-2, -3} };
t0 = 0;
t1 = 1.25;
x0 = {1, -0.5};

(* State transition matrix for LTI system x'(t) = A x(t) *)
Phi[t_] := MatrixExp[A (t - t0)];

xAnalytic = Phi[t1].x0;

Print["A = ", MatrixForm[A]];
Print["Phi(t1,t0) = ", MatrixForm[Phi[t1]]];
Print["x_analytic = ", xAnalytic];

(* Verify defining ODE: d/dt Phi(t) = A Phi(t) *)
PhiDot[t_] := D[Phi[tt], tt] /. tt -> t;
residual = Simplify[PhiDot[t1] - A.Phi[t1]];
Print["PhiDot(t1) - A Phi(t1) = ", MatrixForm[residual]];

(* Numerical check using NDSolve *)
sol = NDSolveValue[{x'[t] == A.x[t], x[t0] == x0}, x, {t, t0, t1},
  AccuracyGoal -> 15, PrecisionGoal -> 15, Method -> "StiffnessSwitching"];

xNumeric = sol[t1];
Print["x_numeric = ", xNumeric];
Print["||x_analytic - x_numeric||_2 = ", Norm[xAnalytic - xNumeric, 2]];

(* Small-time approximation: Phi(t0 + h) ≈ I + A h *)
h = 10^-4;
approx = IdentityMatrix[2] + A h;
err = Norm[Phi[t0 + h] - approx, "Frobenius"];
Print["||Phi(t0+h) - (I + A h)||_F = ", N[err]];

Problem 1 (Matrix IVP for Φ): Let \( \Phi(t,t_0) \) be the state transition matrix for \( \dot{x}=Ax \). Prove that \( \Phi \) satisfies \( \dot{\Phi}(t,t_0)=A\Phi(t,t_0) \) and \( \Phi(t_0,t_0)=I \).

Solution: Construct \( x_i(t) \) as the solution with \( x_i(t_0)=e_i \) and define \( X(t)=[x_1(t)\ \cdots\ x_n(t)] \). Then \( X(t_0)=I \) and

\[ \dot{X}(t)=\begin{bmatrix}\dot{x}_1(t)&\cdots&\dot{x}_n(t)\end{bmatrix} =\begin{bmatrix}Ax_1(t)&\cdots&Ax_n(t)\end{bmatrix}=AX(t). \]

Since \( x(t)=X(t)x_0 \) for any initial condition (by linearity), we identify \( \Phi(t,t_0)=X(t) \), proving the matrix IVP.

Problem 2 (Uniqueness): Suppose \( \Psi(t) \) is a matrix function satisfying \( \dot{\Psi}(t)=A\Psi(t) \) and \( \Psi(t_0)=I \). Show that \( \Psi(t)=\Phi(t,t_0) \).

Solution: For any \( x_0 \), define \( z(t)=\Psi(t)x_0 \). Then \( \dot{z}(t)=\dot{\Psi}(t)x_0=A\Psi(t)x_0=Az(t) \) and \( z(t_0)=Ix_0=x_0 \). By uniqueness of the vector IVP, \( z(t)=\Phi(t,t_0)x_0 \) for all \( x_0 \), hence \( \Psi(t)=\Phi(t,t_0) \).

Problem 3 (Nilpotent Example): Let

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

Compute \( \Phi(t)=e^{At} \) explicitly.

Solution: Note \( A^2=0 \). Therefore the series truncates:

\[ e^{At} = I + At + \frac{(At)^2}{2!}+\cdots = I + At = \begin{bmatrix}1&t\\0&1\end{bmatrix}. \]

Problem 4 (Derivative at the Initial Time): Show that \( \frac{d}{dt}\Phi(t,t_0)\big|_{t=t_0} = A \).

Solution: From the defining equation \( \dot{\Phi}(t,t_0)=A\Phi(t,t_0) \), evaluate at \( t=t_0 \):

\[ \dot{\Phi}(t_0,t_0)=A\Phi(t_0,t_0)=A I = A. \]

Problem 5 (First-Order Approximation): Prove that for small \( h \), \( \Phi(t_0+h,t_0)=I+Ah+O(h^2) \).

Solution: Using the series \( e^{Ah}=\sum_{k=0}^{\infty}\frac{(Ah)^k}{k!} \),

\[ e^{Ah} = I + Ah + \sum_{k=2}^{\infty}\frac{A^k h^k}{k!} = I + Ah + O(h^2). \]

The remainder is order \( h^2 \) because every term has factor \( h^k \) with \( k \ge 2 \).

We defined the state transition matrix \( \Phi(t,t_0) \) as the unique linear operator mapping \( x(t_0) \) to \( x(t) \) for the homogeneous LTI system \( \dot{x}=Ax \). By constructing Φ from basis solutions, we proved its defining matrix IVP \( \dot{\Phi}=A\Phi \), \( \Phi(t_0,t_0)=I \), and then established the identity \( \Phi(t,t_0)=e^{A(t-t_0)} \). These results are the foundation for the semigroup and inverse properties developed in Lesson 2.