Dynamic System Properties

Summary

This chapter establishes the essential mathematical properties that characterize dynamic systems suitable for control analysis. Students will learn the definitions of linearity, time-invariance, and the combined LTI (Linear Time-Invariant) property that underlies most classical control theory. The chapter also covers superposition, homogeneity, causality, and the role of differential equations in describing system dynamics. These properties form the foundation for all subsequent analysis techniques.

Concepts Covered

This chapter covers the following 8 concepts from the learning graph:

Dynamic System
Linear System
Time-Invariant System
LTI System
Superposition Principle
Homogeneity
Causality
Differential Equation

Prerequisites

This chapter builds on concepts from:

Chapter 1: Introduction to Control Systems

The Quest for Mathematical Tractability

In Chapter 1, we learned what control systems do—they regulate, they stabilize, they make things behave. But now comes an important question: how do we actually analyze these systems mathematically? After all, control engineering would be a rather frustrating profession if we had to build every system first and then just hope it works!

The good news is that most systems we care about share certain beautiful mathematical properties that make analysis not only possible but (dare we say it?) elegant. The bad news? These properties come with some Greek letters and formal definitions. But stick with us—once you understand these concepts, they become powerful tools for predicting system behavior without ever touching a screwdriver.

This chapter introduces the key properties that separate "nice" systems (ones we can analyze) from "wild" systems (ones that make mathematicians weep). By the end, you'll understand why the phrase "LTI system" makes control engineers smile with relief.

What Is a Dynamic System?

A dynamic system is any system whose output depends not only on the current input but also on the history of inputs and the system's internal state. In other words, dynamic systems have memory—what happened in the past affects what happens now.

Compare this to a simple resistor, where the current depends only on the voltage applied right now (Ohm's law: $I = V/R$). That's a static or memoryless system. But consider a capacitor: the voltage across it depends on how much charge has accumulated over time. The capacitor "remembers" all the current that has flowed through it. That's dynamic behavior!

System Type	Memory	Example
Static	None	Resistor, lever, gear ratio
Dynamic	Has memory	Capacitor, mass on spring, thermal system

Dynamic systems are described by differential equations because these equations capture how quantities change over time. The relationship between input and output involves derivatives—rates of change—rather than just instantaneous values.

Why Dynamic Systems Matter

Almost every interesting physical system is dynamic. Motors don't instantly reach their commanded speed. Ovens don't instantly reach their set temperature. Aircraft don't instantly change altitude. Understanding dynamic behavior is essential for designing controllers that work in the real world, where everything takes time.

Differential Equations: The Language of Dynamics

Differential equations are the mathematical language we use to describe dynamic systems. They relate the input, output, and their various derivatives (rates of change) to each other.

For a simple RC circuit, the relationship between input voltage $v_{in}(t)$ and output voltage $v_{out}(t)$ across the capacitor is:

\[RC\frac{dv_{out}}{dt} + v_{out} = v_{in}\]

This is a first-order ordinary differential equation (ODE). The "order" refers to the highest derivative present—in this case, the first derivative $dv_{out}/dt$.

For a mass-spring-damper system with mass $m$, damping coefficient $b$, and spring constant $k$:

\[m\frac{d^2y}{dt^2} + b\frac{dy}{dt} + ky = F(t)\]

This is a second-order ODE because it contains a second derivative $d^2y/dt^2$.

The order of the differential equation tells us something important about the system's complexity:

First-order systems: One energy storage element (like a capacitor or thermal mass)
Second-order systems: Two energy storage elements (like an RLC circuit or mass-spring-damper)
Higher-order systems: Three or more energy storage elements

Think of differential equations as the system's "rulebook"—they encode how the system evolves over time. If you know the differential equation and the initial conditions, you can (in principle) predict the output for any input. That's powerful stuff! It's like having a crystal ball, except this one runs on calculus.

Diagram: Differential Equation Forms

Differential Equation Forms

Type: infographic

Bloom Taxonomy: Understand (L2) Bloom Verb: classify, compare

Learning Objective: Students will classify differential equations by their order and identify corresponding physical systems.

Layout: Three columns showing first-order, second-order, and general nth-order forms

Column 1 - First-Order: - General form: $a_1\frac{dy}{dt} + a_0 y = b_0 u$ - Physical examples: RC circuit, thermal system, fluid tank - Schematic: Simple RC circuit diagram - Key feature: "One energy storage element"

Column 2 - Second-Order: - General form: $a_2\frac{d^2y}{dt^2} + a_1\frac{dy}{dt} + a_0 y = b_0 u$ - Physical examples: RLC circuit, mass-spring-damper - Schematic: Mass-spring-damper diagram - Key feature: "Two energy storage elements"

Column 3 - Higher-Order: - General form: $\sum_{k=0}^{n} a_k\frac{d^k y}{dt^k} = \sum_{j=0}^{m} b_j\frac{d^j u}{dt^j}$ - Physical examples: Cascaded systems, complex mechanisms - Schematic: Cascaded tanks diagram - Key feature: "n energy storage elements"

Interactive elements: - Hover over each schematic to see the corresponding differential equation - Click to reveal example numerical values

Visual style: Clean mathematical notation with corresponding circuit/mechanical diagrams Color coding: Blue for first-order, green for second-order, orange for higher-order

Instructional Rationale: Side-by-side comparison helps students see the pattern as order increases and connect abstract equations to physical systems.

Implementation: HTML/CSS/JavaScript with MathJax for equations

Linear Systems: The Gift That Keeps on Giving

A linear system is one that satisfies two fundamental properties: additivity and homogeneity. Together, these properties enable the powerful superposition principle, which is arguably the most useful concept in all of control systems analysis.

Before diving into the formal definitions, here's the intuitive version: in a linear system, effects add up in a predictable, proportional way. Double the input, double the output. Add two inputs together, get the sum of their individual outputs. No surprises, no weird interactions, no chaos. Linear systems are the "well-behaved children" of the mathematical world—they do what you expect!

Homogeneity (Scaling Property)

Homogeneity means that if you scale the input by a constant factor, the output scales by the same factor. Mathematically, if input $u(t)$ produces output $y(t)$, then input $\alpha u(t)$ produces output $\alpha y(t)$ for any constant $\alpha$.

\[\text{If } u(t) \rightarrow y(t), \text{ then } \alpha u(t) \rightarrow \alpha y(t)\]

In plain English: if you push twice as hard, you get twice the response. If you apply half the voltage, you get half the current (in a linear resistor). This is incredibly useful because it means we can analyze a system's response to a "unit" input and then scale the result for any input magnitude.

Real-world example: An ideal amplifier with gain $K$ satisfies homogeneity—input 1 volt, get $K$ volts out; input 2 volts, get $2K$ volts out. But a real amplifier eventually saturates (clips), violating homogeneity. When you crank your guitar amp to 11, the output doesn't scale linearly anymore—you get that glorious distortion. Great for rock music, terrible for control systems!

Additivity (Superposition of Inputs)

Additivity means that the response to a sum of inputs equals the sum of the individual responses. If input $u_1(t)$ produces output $y_1(t)$ and input $u_2(t)$ produces output $y_2(t)$, then input $u_1(t) + u_2(t)$ produces output $y_1(t) + y_2(t)$.

\[\text{If } u_1(t) \rightarrow y_1(t) \text{ and } u_2(t) \rightarrow y_2(t), \text{ then } u_1(t) + u_2(t) \rightarrow y_1(t) + y_2(t)\]

This means effects don't interfere with each other in unexpected ways. You can analyze each input separately and then add up the results. Divide and conquer!

The Superposition Principle

The superposition principle combines homogeneity and additivity into one powerful statement: for a linear system, the response to any linear combination of inputs equals the same linear combination of the individual responses.

\[\alpha_1 u_1(t) + \alpha_2 u_2(t) \rightarrow \alpha_1 y_1(t) + \alpha_2 y_2(t)\]

Why is superposition such a big deal? Because it lets us break complex problems into simpler pieces:

Analyze the response to simple inputs (steps, impulses, sinusoids)
Build up the response to complex inputs by adding these simple responses
Study forced and natural responses separately, then combine them
Decompose any input into a sum of simpler components

Without superposition, we'd have to analyze every possible input scenario individually. With superposition, we can study a system's response to a few canonical inputs and understand its behavior under any input. It's like getting the answer key to an infinite number of problems by solving just a few!

Diagram: Superposition Principle Visualizer

Superposition Principle Visualizer

Type: microsim

Bloom Taxonomy: Apply (L3) Bloom Verb: demonstrate, apply

Learning Objective: Students will demonstrate the superposition principle by observing how the response to combined inputs equals the sum of individual responses.

Canvas layout: - Top section (60%): Three time-response plots stacked vertically - Plot 1: Input u₁(t) and its response y₁(t) - Plot 2: Input u₂(t) and its response y₂(t) - Plot 3: Combined input u₁+u₂ and combined response y₁+y₂ - Bottom section (40%): Controls and equations display

Visual elements: - Each plot shows input (dashed line) and output (solid line) - Plot 3 shows superposition equation: y₁(t) + y₂(t) = y_total(t) - Color coding: Input 1 in blue, Input 2 in green, Combined in purple - Animated drawing of responses when simulation runs

Interactive controls: - Dropdown: Input 1 type (step, ramp, pulse) - Slider: Input 1 magnitude α₁ (-2 to 2, default 1) - Dropdown: Input 2 type (step, ramp, pulse) - Slider: Input 2 magnitude α₂ (-2 to 2, default 0.5) - Slider: System time constant τ (0.5 to 3, default 1) - Button: "Run Simulation" - Button: "Reset" - Toggle: "Show component responses on Plot 3" (overlay individual y₁, y₂ on combined plot)

System model: First-order system G(s) = 1/(τs + 1)

Data Visibility Requirements: - Display α₁, α₂, and τ values - Show mathematical statement: α₁u₁ + α₂u₂ → α₁y₁ + α₂y₂ - When toggle is on, show how y₁ and y₂ "stack up" to form y_total

Behavior: - Plots update in real-time as sliders change - "Run Simulation" animates the responses over time - When inputs are combined, visually show the addition of responses - Demonstrate that scaling inputs scales outputs proportionally

Instructional Rationale: Interactive visualization makes the abstract superposition principle concrete. Students can experiment with different input combinations and magnitudes to verify that superposition holds.

Implementation: p5.js with canvas-based controls and multi-plot display

Testing for Linearity

How do you determine whether a system is linear? The formal test involves checking both homogeneity and additivity. However, there's a practical shortcut for systems described by differential equations.

A system is linear if its governing differential equation has the form:

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

where the coefficients $a_i$ and $b_j$ depend only on time (or are constants), NOT on $y$, $u$, or their derivatives.

Red flags for nonlinearity:

Nonlinear Feature	Example	Why It's Nonlinear
Products of variables	$y \cdot \frac{dy}{dt}$	Output appears multiplicatively
Powers other than 1	$y^2$, $\sqrt{y}$	Scaling doesn't preserve the power
Transcendental functions	$\sin(y)$, $e^y$	These don't scale linearly
Variable coefficients depending on output	$(1+y)\frac{dy}{dt}$	Coefficient changes with output

Most Real Systems Are Nonlinear

Here's a humbling truth: strictly speaking, almost every real physical system is nonlinear! Springs become nonlinear at large deflections. Amplifiers saturate. Friction is often nonlinear. So why do we obsess over linear systems? Because many systems behave approximately linear over a limited operating range—and that approximation unlocks an entire universe of powerful analysis tools. It's like how we use flat-Earth approximations for local navigation—technically wrong, but practically useful!

Helping Gyra

Gyra knows all about nonlinearity. When she's nearly upright, small corrections work beautifully—double the tilt error, double the motor response. But when she's falling over badly? Her motors hit their limits and saturate. She's giving everything she's got, but it's not twice as much as before—it's just... everything. This is why we try to keep Gyra in her "linear zone" where corrections are proportional. Once she leaves that zone, our nice LTI analysis goes out the window and things get unpredictable fast.

Time-Invariant Systems: The Same Today as Tomorrow

A time-invariant system (also called a shift-invariant system) is one whose behavior doesn't change over time. If you apply the same input today, tomorrow, or next year, you get the same output (shifted in time accordingly).

Mathematically, if input $u(t)$ produces output $y(t)$, then the delayed input $u(t - T)$ produces the delayed output $y(t - T)$ for any time shift $T$.

\[\text{If } u(t) \rightarrow y(t), \text{ then } u(t-T) \rightarrow y(t-T)\]

In plain English: the system doesn't "know" what time it is. It doesn't behave differently on Tuesdays or during leap years. It responds to inputs based purely on their shape, not when they occur.

Examples of time-invariant systems:

A resistor (Ohm's law doesn't change with the calendar)
An ideal mass-spring-damper (assuming the spring doesn't fatigue)
A well-maintained motor (before bearings wear out)

Examples of time-varying systems:

A rocket (mass decreases as fuel burns)
A system with scheduled parameter changes
An aging component (characteristics drift over time)
A satellite's control system as it orbits (gravitational field changes)

Time-invariance is crucial for analysis because it means we can characterize a system with a single set of equations that apply for all time. If the system were time-varying, we'd need different equations for different moments—a much harder problem!

Diagram: Time Invariance Test

Time Invariance Test

Type: microsim

Bloom Taxonomy: Analyze (L4) Bloom Verb: compare, differentiate

Learning Objective: Students will differentiate between time-invariant and time-varying systems by comparing responses to time-shifted inputs.

Canvas layout: - Left (50%): Two overlapping plots showing original and shifted responses - Right (50%): Control panel and explanation

Visual elements: - Plot showing u(t) and y(t) in solid lines (original input-output pair) - Plot showing u(t-T) and y(t-T) in dashed lines (shifted pair) - Overlay to compare if shifted input produces shifted output - Vertical markers showing the time shift T - "Time Invariant: YES/NO" indicator based on comparison

Interactive controls: - Dropdown: System type (time-invariant first-order, time-varying example) - Slider: Time shift T (0 to 3 seconds, default 1) - Slider: System parameter (time constant for time-invariant, or varying parameter for time-varying example) - Button: "Apply Shift and Compare" - Button: "Reset"

Time-invariant system: G(s) = 1/(τs + 1) with constant τ Time-varying example: System with τ(t) = τ₀(1 + 0.2t), where time constant increases over time

Data Visibility Requirements: - Show the original input u(t) and output y(t) - Show shifted input u(t-T) and the actual response (not necessarily y(t-T)) - Display whether y(t-T) matches the actual response to u(t-T) - For time-varying system, show how the response shape changes

Behavior: - For time-invariant system: shifted input produces exactly shifted output - For time-varying system: shifted input produces different shape output - Visual highlight when responses don't match (indicating time-varying behavior)

Instructional Rationale: Side-by-side comparison of shifted signals makes the abstract time-invariance property visually concrete. Seeing a time-varying system violate the property reinforces understanding.

Implementation: p5.js with canvas-based controls

The Holy Grail: LTI Systems

An LTI system (Linear Time-Invariant system) is one that satisfies both linearity and time-invariance. This combination is the foundation of classical control theory and the reason we can do so much powerful analysis.

LTI systems are special because:

Superposition applies: We can decompose complex inputs and add up the responses
Time-shift invariance applies: The system behaves consistently regardless of when we observe it
Transfer functions exist: We can characterize the entire system with a single rational function of $s$
Convolution works: Output is the convolution of input with the impulse response
Frequency response is meaningful: Sinusoids in → sinusoids out (same frequency, different amplitude and phase)

Think of LTI systems as the "sweet spot" of control engineering. They're complex enough to model real dynamic behavior, but structured enough to permit elegant mathematical analysis. When control engineers see "LTI," they breathe a sigh of relief—the full toolkit is available!

Property	What It Means	What It Enables
Linear	Effects add proportionally	Superposition, decomposition
Time-Invariant	Behavior is constant over time	Single transfer function, consistent analysis
LTI (Both)	Best of both worlds	Transfer functions, Bode plots, root locus, all classical methods

The LTI Assumption

Throughout most of this textbook, we assume systems are LTI. This isn't because real systems are perfectly LTI—they're not! It's because the LTI assumption provides such powerful analytical tools that engineers find it worthwhile to linearize around operating points and treat systems as approximately LTI. When in doubt, verify the assumption experimentally!

Helping Gyra

Good news: Gyra is (approximately) an LTI system! Her dynamics don't change whether it's Tuesday or Saturday, and small tilts produce proportionally small motor corrections. This means all the powerful tools we're developing—transfer functions, frequency response, stability analysis—apply directly to helping her stay upright. Of course, if you push her too hard, her motors saturate and linearity breaks down. But within her normal operating range? LTI all the way. That's why we can actually design her controller mathematically instead of just guessing.

Causality: No Crystal Balls Allowed

A causal system (also called a non-anticipatory or physical system) is one whose output at any time depends only on current and past inputs, never on future inputs.

\[y(t) \text{ depends only on } u(\tau) \text{ for } \tau \leq t\]

This might seem obvious—of course a physical system can't respond to an input before the input happens! That would require time travel, and last we checked, physics still frowns upon that.

However, causality becomes important when we're doing mathematical analysis. Some perfectly valid mathematical operations can produce non-causal results. For example:

The inverse of a system might be non-causal
Certain ideal filters are non-causal
Optimization over entire time signals can yield non-causal controllers

Causality is a physical constraint that all implementable control systems must satisfy. A controller that needs tomorrow's error signal to compute today's control action isn't going to work in practice—no matter how good its transfer function looks on paper!

Why causality matters in control:

Realizability: Only causal systems can be built and operated in real time
Stability analysis: Causality affects the conditions for stable behavior
Implementation: Digital controllers must be causal to run in real time

Causal vs. Non-Causal

In theoretical analysis, non-causal systems sometimes appear as mathematical constructs. They're useful for understanding limits of performance or as stepping stones in derivations. But when it's time to build something, causality is non-negotiable. The future is, inconveniently, still unknown.

Diagram: Causality Concept Illustration

Causality Concept Illustration

Type: infographic

Bloom Taxonomy: Understand (L2) Bloom Verb: explain, interpret

Learning Objective: Students will explain the concept of causality by visualizing how a causal system's output depends only on past and present inputs.

Layout: Timeline visualization with input and output signals

Visual elements: - Horizontal timeline with "Past," "Present (t)," and "Future" regions - Input signal u(τ) shown as a waveform across the timeline - Output y(t) shown at the present moment - Shaded region showing "inputs that affect y(t)" (past and present only) - Crossed-out "forbidden" region showing future inputs that cannot affect y(t) - "Crystal ball" icon with X through it for humor

Two scenarios: 1. Causal system: Output arrow points only to past/present input region 2. Non-causal (hypothetical): Output arrow also points to future (marked as "impossible in real systems")

Interactive elements: - Slider: Move the "present" moment along the timeline - The "affects output" region updates to show causality - Hover over regions for explanation text

Color scheme: - Past: Blue (accessible) - Present: Green (current) - Future: Gray with red X (inaccessible)

Instructional Rationale: Visual timeline makes the abstract causality concept intuitive. The "forbidden future" visualization emphasizes that physical systems cannot peek ahead in time.

Implementation: HTML/CSS/JavaScript with SVG timeline

Connecting the Concepts

The properties we've covered—dynamic behavior, linearity, time-invariance, causality—work together to define the class of systems that classical control theory handles best.

Here's how they fit together:

Dynamic System
    │
    ├── Linear?
    │     │
    │     ├── Yes: Superposition applies
    │     │     │
    │     │     └── Time-Invariant?
    │     │           │
    │     │           ├── Yes: LTI System! 🎉
    │     │           │     (Transfer functions, Bode plots, all the good stuff)
    │     │           │
    │     │           └── No: Linear Time-Varying (LTV)
    │     │                 (Still useful, but more complex analysis)
    │     │
    │     └── No: Nonlinear System
    │           (Linearize around operating point, or use advanced methods)
    │
    └── Causal?
          │
          ├── Yes: Physically realizable
          │
          └── No: Mathematical abstraction only

The ideal scenario for control analysis is an LTI causal system described by a known differential equation. This is the setting where transfer functions, Bode plots, root locus, and all the classical techniques apply directly.

Diagram: System Properties Classification

System Properties Classification

Type: microsim

Bloom Taxonomy: Analyze (L4) Bloom Verb: classify, organize

Learning Objective: Students will classify systems by their properties (linear/nonlinear, time-invariant/time-varying, causal/non-causal) using a decision tree interface.

Canvas layout: - Left (60%): Interactive decision tree diagram - Right (40%): Example system input and classification result

Visual elements: - Decision tree with nodes for each property test - Current path highlighted as user clicks through - Final classification box showing system type and available analysis tools - Examples panel showing a specific system and its classification

Interactive controls: - Dropdown: Select example system (RC circuit, saturating amplifier, aging battery, etc.) - Click on decision tree nodes to navigate classification - Each terminal node shows: system type, applicable analysis tools, limitations

Example systems: 1. RC circuit (τ constant) → LTI causal 2. Amplifier with saturation → Nonlinear, time-invariant, causal 3. Rocket (decreasing mass) → Linear but time-varying, causal 4. Ideal filter (sin(x)/x impulse response) → LTI but non-causal

Data Visibility Requirements: - Show the governing equation for each example - Highlight which property tests pass/fail - Display final classification prominently

Behavior: - Selecting an example pre-populates the decision path - Users can also manually navigate the tree - Tooltips explain each property test

Instructional Rationale: Decision tree format organizes the classification process systematically. Working through examples reinforces understanding of each property.

Implementation: p5.js or vis-network for interactive tree

Why These Properties Matter for Control Design

Understanding system properties isn't just academic—it directly impacts how you approach control design:

For LTI systems:

Use transfer functions and block diagram algebra
Apply frequency-domain design (Bode, Nyquist)
Use root locus for gain selection
Design PID controllers with standard tuning rules
Predict closed-loop behavior analytically

For nonlinear systems:

Linearize around operating points
Use describing functions (advanced)
Apply nonlinear control techniques (beyond this course)
Rely more heavily on simulation

For time-varying systems:

Parameters may need adaptive adjustment
Gain scheduling may be required
Analysis is more complex (often numerical)

For all real systems:

Verify the LTI assumption is reasonable
Check that the operating range supports linear approximation
Validate models against experimental data
Be prepared for real-world nonlinearities and variations

Key Takeaways

This chapter established the mathematical foundation for control systems analysis:

Dynamic systems have memory—their outputs depend on input history, captured by differential equations
Differential equations are the mathematical language of dynamics, relating inputs, outputs, and their rates of change
Linear systems satisfy homogeneity (scaling) and additivity, enabling the powerful superposition principle
Time-invariant systems behave the same regardless of when you observe them—the system doesn't "know" what time it is
LTI systems (Linear Time-Invariant) combine both properties and form the foundation of classical control theory—when you see "LTI," celebrate!
Causality ensures the system can't respond to future inputs—no time machines allowed in real control systems
Most real systems are approximately LTI within some operating range, which is why we study LTI theory so extensively—it's not perfect, but it's remarkably useful

These properties determine which analysis tools apply to a given system. The LTI assumption, in particular, unlocks the entire toolkit of transfer functions, frequency response, and root locus that we'll develop in subsequent chapters.

Self-Check: Can You Answer These?

What two properties must a system satisfy to be classified as linear?
If a system's output at time $t$ depends on the input at time $t+1$, is the system causal?
A motor's resistance increases as it heats up during operation. Is this system time-invariant?
Why is the superposition principle so valuable for analyzing complex inputs?
You discover that doubling the input to your system more than doubles the output. Is the system linear?