12.3 Solution of state equations

State Transition Matrix and Matrix Exponential

State equations describe how a system's internal variables change over time. Solving them is how you predict a circuit's behavior from any set of initial conditions and inputs. The two main pieces are the state transition matrix (which captures the system's natural dynamics) and the convolution integral (which captures the effect of external inputs).

Fundamental Concepts of State Transition

The state transition matrix $\Phi(t)$ describes how the state vector evolves over time when there's no input. For a linear time-invariant (LTI) system, it equals the matrix exponential $e^{At}$, where $A$ is the system matrix.

You can compute $e^{At}$ using its power series expansion:

$e^{At} = I + At + \frac{(At)^2}{2!} + \frac{(At)^3}{3!} + \cdots$

In practice, you rarely sum this series by hand. Instead, you'll use eigenvalue methods or Laplace transforms (covered below) to find a closed-form expression.

Key properties of $\Phi(t)$ that show up constantly:

• $\Phi(0) = I$ (at $t = 0$, the state hasn't moved yet)
• $\Phi(t_1 + t_2) = \Phi(t_1)\Phi(t_2)$ (semigroup property)
• $\Phi(-t) = \Phi^{-1}(t)$ (time reversal inverts the matrix)

Eigenvalue and Eigenvector Analysis

The most common way to compute $e^{At}$ for small systems is through eigenvalue decomposition.

1. Find the eigenvalues $\lambda$ by solving the characteristic equation $\det(\lambda I - A) = 0$.

2. For each eigenvalue $\lambda_i$, find the corresponding eigenvector $v_i$ by solving $(\lambda_i I - A)v_i = 0$.

3. Form the eigenvector matrix $V = [v_1 \; v_2 \; \cdots \; v_n]$ and the diagonal eigenvalue matrix $\Lambda = \text{diag}(\lambda_1, \lambda_2, \ldots, \lambda_n)$.

4. The state transition matrix is then $\Phi(t) = V e^{\Lambda t} V^{-1}$, where $e^{\Lambda t} = \text{diag}(e^{\lambda_1 t}, e^{\lambda_2 t}, \ldots, e^{\lambda_n t})$.

This works cleanly when all eigenvalues are distinct. If you have repeated eigenvalues, you need the Jordan canonical form, which introduces polynomial-times-exponential terms like $t e^{\lambda t}$ on the off-diagonal blocks.

The eigenvalues themselves tell you the system's natural modes. In a circuit context, they correspond to the natural frequencies you'd find from the characteristic equation of the differential equation.

Homogeneous and Particular Solutions

The complete solution to $\dot{x}(t) = Ax(t) + Bu(t)$ has two parts: the homogeneous (zero-input) response and the particular (zero-state) response.

Homogeneous Solution

When the input $u(t) = 0$, the state equation reduces to $\dot{x}(t) = Ax(t)$, and the solution is:

$x_h(t) = e^{At}x(0)$

This is the system's natural response to initial conditions alone. Stability depends entirely on the eigenvalues of $A$:

• All eigenvalues have negative real parts → asymptotically stable (response decays to zero)
• Some eigenvalues have zero real parts, none positive → marginally stable (response neither grows nor decays)
• Any eigenvalue has a positive real part → unstable (response grows without bound)

For circuit systems, negative real parts correspond to energy dissipation through resistors. A purely imaginary eigenvalue pair means sustained oscillation (like an ideal LC circuit with no resistance).

Particular Solution

When the input $u(t) \neq 0$, you need to account for how the input drives the system. The general particular solution uses the convolution integral:

$x_p(t) = \int_0^t e^{A(t-\tau)} B u(\tau) \, d\tau$

The full solution combining both parts is:

$x(t) = \underbrace{e^{At}x(0)}_{\text{zero-input response}} + \underbrace{\int_0^t e^{A(t-\tau)} B u(\tau) \, d\tau}_{\text{zero-state response}}$

For simple inputs (step, ramp, sinusoidal), you can sometimes use the method of undetermined coefficients to guess the form of the particular solution and solve for its coefficients. For arbitrary inputs, the convolution integral or Laplace transform approach is the way to go.

Alternative Solution Methods

Laplace Transform Approach

The Laplace transform converts the state equation from a matrix differential equation into a matrix algebra problem, which is often easier to handle.

1. Take the Laplace transform of $\dot{x}(t) = Ax(t) + Bu(t)$: $sX(s) - x(0) = AX(s) + BU(s)$

2. Rearrange to isolate $X(s)$: $(sI - A)X(s) = x(0) + BU(s)$

3. Solve for $X(s)$: $X(s) = (sI - A)^{-1}x(0) + (sI - A)^{-1}BU(s)$

4. Take the inverse Laplace transform to get $x(t)$.

The matrix $(sI - A)^{-1}$ is called the resolvent matrix. Its inverse Laplace transform gives you the state transition matrix: $e^{At} = \mathcal{L}^{-1}\{(sI - A)^{-1}\}$. This is actually one of the most practical ways to compute $e^{At}$ for 2×2 and 3×3 systems.

This approach also connects state-space analysis to transfer function analysis. The transfer function matrix is $H(s) = C(sI - A)^{-1}B + D$, which bridges the gap between the state-space and frequency-domain representations you've used in earlier units.

Numerical Solution Techniques

When systems are nonlinear, time-varying, or just large enough that closed-form solutions become impractical, numerical methods take over.

Euler's method is the simplest approach. Given the current state, you step forward by a small time increment $h$:

$x(t + h) \approx x(t) + h[Ax(t) + Bu(t)]$

This is a first-order method, so errors accumulate quickly unless $h$ is very small.

Runge-Kutta methods (especially RK4) provide much better accuracy by evaluating the derivative at multiple points within each step, then taking a weighted average. RK4 is fourth-order accurate, meaning the error per step scales as $h^5$.

In practice, you'll typically use tools like MATLAB's ode45, which implements an adaptive-step Runge-Kutta algorithm. It automatically adjusts the step size: smaller steps where the solution changes rapidly, larger steps where it's smooth. Simulink provides a block-diagram environment for simulating state-space models visually, which is especially useful for verifying your analytical solutions against numerical results.