In classical linear control, a single-input single-output (SISO) LTI system is described by a constant-coefficient ordinary differential equation (ODE) of order \( n \):

\[ a_n \frac{d^n y(t)}{dt^n} + a_{n-1} \frac{d^{n-1} y(t)}{dt^{n-1}} + \cdots + a_1 \frac{dy(t)}{dt} + a_0 y(t) = \\ b_m \frac{d^m u(t)}{dt^m} + b_{m-1} \frac{d^{m-1} u(t)}{dt^{m-1}} + \cdots + b_1 \frac{du(t)}{dt} + b_0 u(t), \]

where the coefficients \( a_i \), \( b_j \) are real constants and \( m \le n \) for properness. Taking Laplace transforms and assuming zero initial conditions, i.e. all derivatives of \( y(t) \) at \( t=0 \) equal zero, yields the algebraic relation

\[ Y(s) = G(s) U(s), \quad G(s) = \frac{b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0}{a_n s^n + a_{n-1} s^{n-1} + \cdots + a_0}, \]

where \( G(s) \) is the transfer function. Root locus, Bode, and Nyquist methods all start from this scalar rational function.

Conceptually, this imposes three major structural assumptions:

• LTI dynamics (time-invariant, linear, finite-dimensional ODE).
• SISO I/O description: one input \( u(t) \), one output \( y(t) \).
• Zero initial conditions for the input-output relation \( Y(s) = G(s) U(s) \).

Much of modern control is motivated by the fact that realistic systems violate one or more of these assumptions, and classical transfer function methods become insufficient or awkward.

flowchart TD
  P["Physical system"] --> LTI["Linear LTI ODE (SISO)"]
  LTI --> TF["Transfer function G(s)"]
  TF --> DES["Frequency-domain design (Bode, Nyquist, root locus)"]
  DES --> CL["Closed-loop T(s)"]
  CL --> LIM1["No explicit internal state"]
  CL --> LIM2["Difficult MIMO, time-varying, nonlinear, constraints"]
        

A central (and sometimes overlooked) assumption in the transfer function relation \( Y(s)=G(s)U(s) \) is the requirement of zero initial conditions. To see this explicitly, consider a second-order LTI system

\[ \frac{d^2 y(t)}{dt^2} + a_1 \frac{dy(t)}{dt} + a_0 y(t) = b_0 u(t), \]

with initial conditions \( y(0)=y_0 \), \( \dot y(0)=\dot y_0 \). Taking the Laplace transform gives

\[ \begin{aligned} \mathcal{L}\left\{\frac{d^2 y}{dt^2}\right\} &= s^2 Y(s) - s y_0 - \dot y_0, \\ \mathcal{L}\left\{\frac{dy}{dt}\right\} &= s Y(s) - y_0, \\ \mathcal{L}\left\{y(t)\right\} &= Y(s), \quad \mathcal{L}\left\{u(t)\right\} = U(s). \end{aligned} \]

Substituting into the ODE yields

\[ \bigl(s^2 + a_1 s + a_0\bigr) Y(s) - (s + a_1) y_0 - \dot y_0 = b_0 U(s). \]

Solving for \( Y(s) \) gives

\[ Y(s) = \underbrace{\frac{b_0}{s^2 + a_1 s + a_0}}_{G(s)} U(s) + \frac{(s + a_1) y_0 + \dot y_0}{s^2 + a_1 s + a_0}. \]

Thus,

\[ Y(s) = G(s) U(s) \quad \text{if and only if} \quad y_0 = 0,\; \dot y_0 = 0. \]

For nonzero initial conditions, we can interpret the extra term as a fictitious additional input depending on the unknown internal state at \( t=0 \). Classical design based on \( G(s) \) alone therefore:

• Cannot distinguish between different initial states that share the same input.
• Cannot describe the internal transient driven purely by initial conditions with the same simplicity as input-driven response.

Modern (state-space) control will handle initial conditions symmetrically with inputs by working directly with internal state variables rather than only the input-output map.

Classical tools are fundamentally designed for SISO transfer functions. A general LTI system with \( m \) inputs and \( p \) outputs can be written in the Laplace domain as

\[ \mathbf{Y}(s) = \mathbf{G}(s) \mathbf{U}(s), \]

where \( \mathbf{U}(s) \in \mathbb{C}^m \), \( \mathbf{Y}(s) \in \mathbb{C}^p \), and \( \mathbf{G}(s) \in \mathbb{C}^{p \times m} \) is a matrix of scalar transfer functions \( G_{ij}(s) \).

Even at this purely algebraic level, several issues appear:

• Classical design techniques (root locus, Bode plots, Nyquist) operate on scalar transfer functions, not on matrices.
• Attempting to design loop-by-loop (treating each \( G_{ii}(s) \) as if it were SISO) ignores off-diagonal coupling \( G_{ij}(s),\, i\ne j \).
• Stability and performance of the full MIMO feedback interconnection depend on all entries of \( \mathbf{G}(s) \), not only the diagonal ones.

For a 2-input 2-output plant, for example,

\[ \begin{bmatrix} Y_1(s) \\[4pt] Y_2(s) \end{bmatrix} = \begin{bmatrix} G_{11}(s) & G_{12}(s) \\ G_{21}(s) & G_{22}(s) \end{bmatrix} \begin{bmatrix} U_1(s) \\[4pt] U_2(s) \end{bmatrix}, \]

cross-couplings \( G_{12}(s) \) and \( G_{21}(s) \) generically prevent independent SISO designs from being valid. Classical loop-by-loop design becomes heuristic rather than systematic.

The state-space framework, by contrast, treats input and output vectors natively and will later provide tools explicitly tailored to MIMO systems.

flowchart TD
  SISO["SISO G(s)"] --> TOOLS["Root locus / Bode / Nyquist"]
  MIMO["MIMO G(s) matrix"] --> ISSUE1["Loop-by-loop design ignores coupling"]
  MIMO --> ISSUE2["No direct scalar frequency tools"]
  TOOLS --> H1["Well-developed SISO theory"]
  ISSUE1 --> NEED["Need structured multivariable methods"]
  ISSUE2 --> NEED
        

The transfer function approach relies crucially on constant coefficients in the ODE. Consider a scalar time-varying system

\[ \frac{dy(t)}{dt} = a(t) y(t) + b(t) u(t), \]

where \( a(t) \), \( b(t) \) are arbitrary continuous functions of time. Taking Laplace transforms,

\[ s Y(s) - y(0) = \mathcal{L}\{a(t) y(t)\} + \mathcal{L}\{b(t) u(t)\}, \]

but \( \mathcal{L}\{a(t) y(t)\} \) does not simplify to \( a Y(s) \) for a constant \( a \); instead it becomes a convolution in the Laplace domain. There is no rational function \( G(s) \) such that \( Y(s) = G(s) U(s) \) for all inputs.

For nonlinear systems, e.g.

\[ \frac{dy(t)}{dt} = f\bigl(y(t), u(t)\bigr), \]

Laplace transforms no longer convert the ODE into an algebraic equation. The superposition principle fails and there is no canonical concept of a transfer function capturing the full nonlinear behavior.

Classical practice often linearizes around an operating point, obtaining an approximate LTI model, and then applies transfer function methods. However:

• The validity of the linear approximation is local and may break down for large excursions.
• Nonlinear phenomena (saturation, dead zones, hysteresis) are not captured by the transfer function.

A central aim of modern control is to start from a more fundamental description (state equations) that can be used for linearization, time-varying analysis, and systematic handling of nonlinearities.

The transfer function characterizes only the input-output map. Internal variables and internal modes are not uniquely determined by \( G(s) \). In particular, different internal realizations can share the same transfer function.

A classical example is the phenomenon of pole–zero cancellation. Suppose we have the transfer function

\[ G(s) = \frac{s-1}{s-1} = 1, \]

which is indistinguishable, from an input-output viewpoint, from the trivial gain system \( y(t) = u(t) \). However, \( G(s) \) might arise as the cascade of two subsystems:

\[ G(s) = G_2(s) G_1(s), \quad G_1(s) = \frac{1}{s-1}, \quad G_2(s) = s-1. \]

If the internal state associated with \( G_1(s) \) is unstable (due to the pole at \( s=1 \)), then the overall physical system can exhibit internal growth even though its input-output transfer function is identically 1. The cancellation hides an internal unstable mode from the transfer function description.

From the standpoint of classical design, which uses only \( G(s) \), these internal instabilities are invisible. Modern state-space theory will later give tools to distinguish such realizations and to separate observable, reachable internal modes from hidden ones.

In summary, the transfer function cannot:

• Uniquely specify internal dynamics associated with the same input-output behavior.
• Reveal hidden unstable modes that are structurally cancelled in the transfer function.
• Express directly how actuators and sensors constrain internal variables.

Real actuators are constrained in magnitude and rate. Consider a saturating actuator with commanded signal \( v(t) \) and physical input to the plant \( u(t) \) defined by

\[ u(t) = \begin{cases} u_{\max}, & v(t) > u_{\max}, \\ v(t), & u_{\min} \le v(t) \le u_{\max}, \\ u_{\min}, & v(t) < u_{\min}. \end{cases} \]

This nonlinearity destroys the validity of a single linear transfer function model for the closed-loop system; the effective input-output behavior depends on whether the actuator is saturated or not, which changes over time and depends on internal signals.

In classical design, saturation is typically handled by ad hoc modifications (gain reduction, manual tuning, trial-and-error). In contrast, a state-based description naturally incorporates actuator limits as algebraic constraints on the state and input, enabling more systematic analysis (to be developed later).

We illustrate, using Python, the difference between an LTI system fully described by a transfer function and a time-varying, saturating system for which no single transfer function is adequate. We use the control library for classical LTI analysis and scipy.integrate for ODE simulation.

import numpy as np
import matplotlib.pyplot as plt

# Classical LTI second-order system: y'' + 2*zeta*wn*y' + wn^2 y = wn^2 u
zeta = 0.3
wn = 2.0

# Transfer function representation using python-control
import control as ct

num = [wn**2]
den = [1.0, 2*zeta*wn, wn**2]
G = ct.TransferFunction(num, den)

t = np.linspace(0.0, 10.0, 1000)
t_out, y_step = ct.step_response(G, t)

# Time-varying, saturating version of the same nominal plant
def sat(v, umin=-1.0, umax=1.0):
    return np.maximum(umin, np.minimum(umax, v))

def tv_saturating_ode(t, x, u_cmd):
    # Example: time-varying damping and stiffness
    a1 = 2*zeta*wn * (1.0 + 0.5*np.sin(0.5*t))
    a0 = wn**2 * (1.0 + 0.3*np.cos(0.2*t))

    # Saturated input
    u_phys = sat(u_cmd(t))

    # x = [y, ydot]
    y, ydot = x
    yddot = -a1*ydot - a0*y + wn**2*u_phys
    return np.array([ydot, yddot])

# Simulate the time-varying system using solve_ivp
from scipy.integrate import solve_ivp

def step_input(t):
    return 2.0  # command exceeds actuator limits

def simulate_tv_system(x0):
    sol = solve_ivp(
        fun=lambda tt, xx: tv_saturating_ode(tt, xx, step_input),
        t_span=(0.0, 10.0),
        y0=x0,
        t_eval=t
    )
    return sol.t, sol.y[0]

t_tv, y_tv = simulate_tv_system(x0=[0.0, 0.0])

plt.figure()
plt.plot(t_out, y_step, label="LTI transfer function step response")
plt.plot(t_tv, y_tv, linestyle="--", label="Time-varying, saturating plant")
plt.xlabel("t")
plt.ylabel("y(t)")
plt.legend()
plt.grid(True)
plt.show()
      

The LTI system is fully described by G. The time-varying, saturating system has no single transfer function; we must simulate its ODE directly. This exemplifies a core limitation of the transfer function picture.

In C++, there is no standard high-level transfer function library. Classical control is usually implemented either via numerical libraries (for root locus, Bode, etc.) or via direct numerical integration of ODEs. The latter is already closer to the state-space viewpoint.

The following code performs a simple Euler integration of a saturating, time-varying second-order system similar to the Python example. Note how we directly manipulate internal variables y and ydot rather than any transfer function.

#include <iostream>
#include <vector>
#include <cmath>

double sat(double v, double umin, double umax) {
    if (v < umin) return umin;
    if (v > umax) return umax;
    return v;
}

int main() {
    const double zeta = 0.3;
    const double wn   = 2.0;

    double t0 = 0.0;
    double tf = 10.0;
    double dt = 0.001;

    double y    = 0.0;
    double ydot = 0.0;

    auto u_cmd = [](double t) {
        return 2.0; // step command that saturates
    };

    std::vector<double> t_vec;
    std::vector<double> y_vec;

    for (double t = t0; t <= tf; t += dt) {
        // time-varying parameters
        double a1 = 2*zeta*wn * (1.0 + 0.5*std::sin(0.5*t));
        double a0 = wn*wn * (1.0 + 0.3*std::cos(0.2*t));

        double u_phys = sat(u_cmd(t), -1.0, 1.0);

        double yddot = -a1*ydot - a0*y + wn*wn*u_phys;

        // Euler integration
        y    += dt*ydot;
        ydot += dt*yddot;

        t_vec.push_back(t);
        y_vec.push_back(y);
    }

    // For brevity, print only a few samples
    for (std::size_t k = 0; k < t_vec.size(); k += 1000) {
        std::cout << t_vec[k] << " " << y_vec[k] << "\n";
    }
    return 0;
}
      

This low-level numerical integration naturally exposes internal variables. A pure transfer function description cannot even be written for this time-varying, saturating system.

We now sketch a Java example of a simple 2-input 2-output coupled system:

\[ \begin{aligned} \dot y_1(t) &= -y_1(t) + 0.5 y_2(t) + u_1(t), \\ \dot y_2(t) &= 0.3 y_1(t) - y_2(t) + u_2(t). \end{aligned} \]

The corresponding matrix transfer function \( \mathbf{G}(s) \) is 2 × 2. Classical loop-by-loop design would try to treat each channel separately, but the ODE reveals explicit cross-coupling. We numerically integrate the system in Java:

public class MimoCoupledSystem {

    public static void main(String[] args) {
        double t0 = 0.0;
        double tf = 10.0;
        double dt = 0.001;

        double y1 = 0.0;
        double y2 = 0.0;

        for (double t = t0; t <= tf; t += dt) {
            double u1 = 1.0;          // simple constant inputs
            double u2 = 0.5;

            double dy1 = -y1 + 0.5*y2 + u1;
            double dy2 = 0.3*y1 - y2 + u2;

            y1 += dt*dy1;
            y2 += dt*dy2;

            if (Math.abs(t - 1.0*Math.round(t)) < 1e-6) {
                System.out.printf("t=%.1f, y1=%.4f, y2=%.4f%n", t, y1, y2);
            }
        }
    }
}
      

Although a 2 × 2 transfer function matrix can be written for this system, classical SISO tools provide no direct way to design a controller that simultaneously respects the coupling. Working at the ODE (and later state-space) level makes such coupling explicit.

MATLAB provides the Control System Toolbox with high-level commands for transfer function models:

% Classical LTI plant
zeta = 0.3;
wn   = 2.0;

num = wn^2;
den = [1, 2*zeta*wn, wn^2];
G = tf(num, den);

% Closed-loop with unity feedback
T = feedback(G, 1);

t = linspace(0, 10, 1000);
[y_step, t_out] = step(T, t);

figure;
plot(t_out, y_step);
grid on;
xlabel('t');
ylabel('y(t)');
title('Unity-feedback step response (LTI transfer function)');
      

For systems with saturation and nonlinearities, it is standard to move to a block-diagram representation (e.g. Simulink) with explicit integrators and nonlinear blocks:

% Sketch of setting up a Simulink model programmatically (conceptual)
model = 'tv_saturating_plant';
new_system(model);
open_system(model);

% Add integrators, sum blocks, saturation, etc. (block positions omitted)
add_block('simulink/Commonly Used Blocks/Integrator', [model '/Int1']);
add_block('simulink/Commonly Used Blocks/Integrator', [model '/Int2']);
add_block('simulink/Math Operations/Sum', [model '/Sum']);
add_block('simulink/Discontinuities/Saturation', [model '/Sat']);

% ... connect lines and set parameters, then simulate with sim(model) ...
      

The need to leave the scalar transfer function representation and move to explicit integrator and nonlinear blocks is a practical manifestation of the theoretical limitations discussed earlier. Simulink models are essentially state-based descriptions, anticipating the formal state-space framework.

Wolfram Mathematica provides high-level functions for transfer function modeling as well as direct differential equation simulation. For the LTI second-order plant, one may write:

zeta = 0.3;
wn   = 2.0;

G = TransferFunctionModel[
      wn^2 / (s^2 + 2 zeta wn s + wn^2),
      s
    ];

(* Step response of the LTI transfer function *)
ltis = OutputResponse[G, UnitStep[t], {t, 0, 10}];
Plot[ltis, {t, 0, 10}, AxesLabel -> {"t", "y(t)"}, PlotRange -> All]
      

For a time-varying version with saturation, we must instead solve the ODE directly:

zeta = 0.3;
wn   = 2.0;
umin = -1.0;
umax = 1.0;

uCmd[t_] := 2.0;

sat[v_] := Min[umax, Max[umin, v]];

tvSystem = NDSolve[
  {
    y'[t] == v[t],
    v'[t] == -2 zeta wn (1 + 0.5 Sin[0.5 t]) v[t]
             - wn^2 (1 + 0.3 Cos[0.2 t]) y[t]
             + wn^2 sat[uCmd[t]],
    y[0] == 0,
    v[0] == 0
  },
  {y, v},
  {t, 0, 10}
];

Plot[
  Evaluate[y[t] /. tvSystem],
  {t, 0, 10},
  AxesLabel -> {"t", "y(t)"},
  PlotRange -> All
]
      

Again, the time-varying, saturating system must be treated via its differential equations. There is no single transfer function \( G(s) \) that governs all operating regimes.

Problem 1 (General LTI ODE and Transfer Function): Consider the scalar nth-order LTI ODE

\[ a_n \frac{d^n y(t)}{dt^n} + a_{n-1} \frac{d^{n-1} y(t)}{dt^{n-1}} + \cdots + a_0 y(t) = b_m \frac{d^m u(t)}{dt^m} + b_{m-1} \frac{d^{m-1} u(t)}{dt^{m-1}} + \cdots + b_0 u(t), \]

with all initial conditions equal to zero. Derive the general expression for the transfer function \( G(s) = Y(s)/U(s) \).

Solution:

Applying the Laplace transform with zero initial conditions yields

\[ a_n s^n Y(s) + a_{n-1} s^{n-1} Y(s) + \cdots + a_0 Y(s) = b_m s^m U(s) + b_{m-1} s^{m-1} U(s) + \cdots + b_0 U(s). \]

Factoring out \( Y(s) \) and \( U(s) \) gives

\[ \bigl(a_n s^n + a_{n-1} s^{n-1} + \cdots + a_0\bigr) Y(s) = \bigl(b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0\bigr) U(s). \]

Therefore,

\[ G(s) = \frac{Y(s)}{U(s)} = \frac{b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0} {a_n s^n + a_{n-1} s^{n-1} + \cdots + a_0}. \]

Problem 2 (Role of Initial Conditions): For the second-order system

\[ \frac{d^2 y(t)}{dt^2} + 2 \zeta \omega_0 \frac{dy(t)}{dt} + \omega_0^2 y(t) = \omega_0^2 u(t), \]

derive \( Y(s) \) in terms of \( U(s) \) and the initial conditions \( y(0)=y_0 \), \( \dot y(0)=\dot y_0 \). Show explicitly how the initial conditions appear as an additive term that is not captured by the transfer function.

Solution:

As in Section 2, the Laplace transform gives

\[ \bigl(s^2 + 2 \zeta \omega_0 s + \omega_0^2\bigr) Y(s) - (s + 2 \zeta \omega_0) y_0 - \dot y_0 = \omega_0^2 U(s). \]

Solving for \( Y(s) \),

\[ Y(s) = \frac{\omega_0^2}{s^2 + 2 \zeta \omega_0 s + \omega_0^2} U(s) + \frac{(s + 2 \zeta \omega_0) y_0 + \dot y_0} {s^2 + 2 \zeta \omega_0 s + \omega_0^2}. \]

The first term is \( G(s) U(s) \), with \( G(s) = \omega_0^2/(s^2 + 2 \zeta \omega_0 s + \omega_0^2) \). The second term, depending on \( y_0 \), \( \dot y_0 \), is an additional contribution that cannot be expressed as \( G(s) U(s) \). Hence the transfer function describes only the zero-initial-condition input-output map.

Problem 3 (No Transfer Function for Time-Varying Coefficients): Show that for the time-varying system

\[ \frac{dy(t)}{dt} = a(t) y(t) + u(t), \]

with a non-constant continuous function \( a(t) \), there is no rational transfer function \( G(s) \) such that \( Y(s) = G(s) U(s) \) holds for all inputs \( u(t) \).

Solution:

Taking Laplace transforms (with zero initial condition for simplicity),

\[ s Y(s) = \mathcal{L}\{a(t) y(t)\} + U(s). \]

If there were a transfer function \( G(s) \) such that \( Y(s) = G(s) U(s) \) for all \( u(t) \), then

\[ s G(s) U(s) = \mathcal{L}\{a(t) y(t)\} + U(s). \]

However, \( y(t) \) itself depends on \( u(t) \) in a complicated way, and \( \mathcal{L}\{a(t) y(t)\} \) is not equal to \( a Y(s) \) for any constant \( a \) unless \( a(t) \) is constant. In general, the Laplace transform of the product \( a(t) y(t) \) becomes a convolution in the Laplace domain, which cannot be represented as multiplication by a single rational function \( G(s) \) valid for all inputs. Thus, no universal rational transfer function exists for the time-varying system.

Problem 4 (Coupled MIMO Plant): Consider the 2-input 2-output plant

\[ \begin{aligned} \dot y_1(t) &= -y_1(t) + \alpha y_2(t) + u_1(t), \\ \dot y_2(t) &= \beta y_1(t) - y_2(t) + u_2(t), \end{aligned} \]

where \( \alpha \), \( \beta \) are nonzero constants. Compute the transfer function matrix \( \mathbf{G}(s) \) and comment on why loop-by-loop SISO design (ignoring off-diagonal terms) is, in general, insufficient.

Solution:

Taking Laplace transforms (zero initial conditions),

\[ \begin{aligned} s Y_1(s) &= -Y_1(s) + \alpha Y_2(s) + U_1(s), \\ s Y_2(s) &= \beta Y_1(s) - Y_2(s) + U_2(s). \end{aligned} \]

Rearranging,

\[ \begin{bmatrix} s+1 & -\alpha \\ -\beta & s+1 \end{bmatrix} \begin{bmatrix} Y_1(s) \\[4pt] Y_2(s) \end{bmatrix} = \begin{bmatrix} U_1(s) \\[4pt] U_2(s) \end{bmatrix}. \]

Hence

\[ \mathbf{G}(s) = \begin{bmatrix} G_{11}(s) & G_{12}(s) \\ G_{21}(s) & G_{22}(s) \end{bmatrix} = \begin{bmatrix} s+1 & -\alpha \\ -\beta & s+1 \end{bmatrix}^{-1}. \]

Computing the inverse,

\[ \mathbf{G}(s) = \frac{1}{(s+1)^2 - \alpha \beta} \begin{bmatrix} s+1 & \alpha \\ \beta & s+1 \end{bmatrix}. \]

The off-diagonal entries \( G_{12}(s) \), \( G_{21}(s) \) are nonzero whenever \( \alpha, \beta \ne 0 \), indicating that \( y_1 \) depends on \( u_2 \) and \( y_2 \) depends on \( u_1 \). A loop-by-loop design that treats \( G_{11}(s) \) and \( G_{22}(s) \) in isolation ignores this coupling, and may yield poor performance or even instability when both loops are closed simultaneously. This is a structural limitation of SISO classical methods.

Problem 5 (Decision Flow: When Transfer Functions Are Insufficient): Sketch a conceptual decision flow that starts from a physical system and indicates conditions under which a pure transfer function approach is adequate and conditions under which a more general state-space description is required.

Solution (flow):

flowchart TD
  START["Physical system model"] --> L1["Can it be approximated as LTI?"]
  L1 -->|no| SS["Use general state equations \nand numerical simulation"]
  L1 -->|yes| L2["Is it effectively \nSISO and unconstrained?"]
  L2 -->|yes| TFOK["Transfer function methods \nlikely adequate"]
  L2 -->|no| L3["Strong MIMO coupling, \ntime-varying, or constraints?"]
  L3 -->|yes| SS
  L3 -->|no| HYB["Hybrid: transfer functions \nplus state-based checks"]
        

The flow emphasizes that classical transfer function methods are well suited for LTI, SISO, unconstrained settings. Once MIMO coupling, time variation, nonlinearities, or constraints become essential, a state-space framework is needed.

In this lesson we critically examined the classical transfer function framework. We showed that:

• The relation \( Y(s)=G(s)U(s) \) fundamentally assumes LTI dynamics and zero initial conditions.
• Transfer functions are intrinsically SISO objects; MIMO systems require matrix transfer functions for which classical SISO tools provide only heuristic guidance.
• Time-varying and nonlinear systems do not admit a universal rational transfer function; we must revert to differential equations and numerical simulation.
• Internal dynamics, hidden modes, and actuator constraints are not directly represented in the transfer function, leading to potential hidden instabilities and unmodeled behavior.

These limitations motivate the state-space viewpoint, which will treat internal states, multi-variable couplings, and general classes of dynamics in a unified way. The next lessons will introduce state variables and internal dynamics more systematically.