LTI Systems: Properties, Convolution, Stability & Causality

Core Concepts: What Makes a System LTI?

A Linear Time-Invariant (LTI) system is the foundation of digital signal processing. It satisfies three key properties:

1. Linearity: Superposition and homogeneity hold.
2. Time-invariance: System behavior does not change over time.
3. Memory: Output depends on past, present, and future inputs (unless non-causal).

1. Linearity: Superposition and Homogeneity

A system is linear if it obeys:

• Additivity (Superposition): $y(t)=y_1(t)+y_2(t)$ when $x(t)=x_1(t)+x_2(t)$.
• Homogeneity (Scaling): $y(at)=ay(t)$ when $x(at)=ax(t)$.

Visual Check:

graph LR
    A["Input: x₁(t)"] -->|"System"| B["Output: y₁(t)"]
    C["Input: x₂(t)"] -->|"System"| D["Output: y₂(t)"]
    E["Combined Input: x₁(t) + x₂(t)"] -->|"System"| F["Output: y₁(t) + y₂(t)"]
    G["Scaled Input: a·x(t)"] -->|"System"| H["Output: a·y(t)"]

Example: If a system processes an audio signal $x(t)$ (e.g., WhatsApp voice note) and outputs $y(t)$, linearity ensures that mixing two notes $x_1(t)+x_2(t)$ produces $y_1(t)+y_2(t)$.

Nonlinear Example: A rectifier circuit (used in power supplies) violates linearity because $y(t)=|x(t)|$. Doubling input does not double output.

2. Time-Invariance: Unchanging Behavior Over Time

A system is time-invariant (TI) if a time-shifted input produces a time-shifted output: $$\text{If }x(t)\to y(t),\text{ then }x(t-t_0)\to y(t-t_0).$$

Real-World Analogy:

• Ncell’s call routing: The system’s rules for connecting calls (e.g., "if busy, redirect") do not change over time.
• Khalti’s transaction processing: A payment of ₹100 at 10 AM or 10 PM follows the same validation rules.

Non-TI Example: A traffic light controller that changes its timing based on the day of the week is time-variant.

3. Impulse Response and Convolution

Impulse Response $h(t)$

The output of an LTI system when the input is a unit impulse $\delta (t)$ is called the impulse response $h(t)$. It fully characterizes the system.

Example: For a low-pass filter (used in WhatsApp’s voice clarity enhancement), the impulse response $h(t)$ might look like:

The output $y(t)$ for any input $x(t)$ is the convolution of $x(t)$ and $h(t)$: $$y(t)=x(t)\ast h(t)={\int }_{-\infty }^{\infty }x(\tau )h(t-\tau )d\tau .$$

Convolution in Discrete Time

For digital signals (e.g., sampled audio in YouTube’s compression), convolution becomes: $$y[n]=x[n]\ast h[n]=\sum _{k=-\infty }^{\infty }x[k]h[n-k].$$

Worked Example: Convolution of Two Sequences Let:

• $x[n]=\{1,2,1\}$ (a 3-sample window).
• $h[n]=\{1,1\}$ (a simple moving average filter).

Compute $y[n]=x[n]\ast h[n]$:

Output: $y[n]=\{0,1,3,3,1\}$.

Real-World Tie-In: This is how Daraz’s order processing system smooths out sudden spikes in orders (e.g., during sales). The "input" $x[n]$ is the order volume at each time step, and the "filter" $h[n]$ averages it to predict server load.

4. Stability and Causality

Stability

An LTI system is BIBO (Bounded-Input Bounded-Output) stable if every bounded input produces a bounded output. Mathematically: $$|x(t)|\le M<\infty ⟹|y(t)|\le N<\infty .$$

Condition for Stability: For continuous-time systems: $${\int }_{-\infty }^{\infty }|h(t)|dt<\infty .$$ For discrete-time systems: $$\sum _{n=-\infty }^{\infty }|h[n]|<\infty .$$

Example: A system with impulse response $h[n]=a^{n}u[n]$ (where $|a|<1$) is stable because the sum converges.

Unstable Example: $h[n]=2^{n}u[n]$ is unstable because $\sum |2^n|$ diverges.

Causality

A system is causal if its output at time $t$ depends only on present and past inputs, not future inputs: $$y(t)=\mathcal{L}\{x(\tau ){\}}_{-\infty }^t.$$

Example:

• Causal: A FIR filter (used in audio equalizers) processes samples sequentially.
• Non-causal: A spectral analyzer (e.g., in NEPSE stock trend analysis) may need future data to compute Fourier transforms.

Real-World Example:

• Pathao’s ride allocation: Uses only past and current demand data (causal).
• NTC’s traffic prediction: May use future weather data (non-causal).

5. Properties of LTI Systems

6. System Classification

In the Real World

1. WhatsApp Voice Notes:

   • Convolution: The app applies FIR filters (linear, time-invariant) to reduce background noise. The impulse response $h[n]$ is designed to suppress high frequencies (noise) while preserving speech.
   • Stability: The filters are BIBO stable to avoid distortion during long recordings.

2. NEPSE Stock Trend Analysis:

   • LTI Systems: Analysts use moving average filters (convolution of price data with a window) to smooth out volatility. For example, a 5-day moving average: $$y[n]=\frac{1}{5}\sum _{k=0}^{4}x[n-k].$$
   • Causality: Predictive models (e.g., ARIMA) are causal—they use past prices to forecast future trends.

3. Khalti’s Fraud Detection:

   • Nonlinearity Check: Transactions are first passed through a linear preprocessor (e.g., normalization) to meet LTI assumptions before applying anomaly detection (which may be nonlinear).
   • Time-Invariance: Rules like "block transactions > ₹50,000 without OTP" are time-invariant.

Exam Tip

1. Always check linearity and time-invariance before assuming a system is LTI. Many exam questions test this with counterexamples (e.g., $y(t)=x^2(t)$ is nonlinear).
2. Convolution is the most tested operation:
   • Memorize the graphical method (flipping, shifting, multiplying, integrating).
   • For discrete signals, use the tabular method (as shown in the worked example).
3. Stability questions often involve impulse responses:
   • If $h[n]$ is an exponential decay ($a^{n}u[n]$), check $|a|<1$ for stability.
4. Causality is about time dependence:
   • Non-causal systems appear in spectral analysis (e.g., FFT requires future samples).
5. Real-world applications:
   • Tie convolution to filtering (audio, images), prediction (stocks, weather), and control systems (traffic lights, robotics).
   • For Nepali context, relate LTI systems to:
     • NTC’s traffic flow modeling (convolution of vehicle counts).
     • Ncell’s call routing (linear queuing systems).
     • eSewa’s payment processing (stability under high transaction loads).

Key Formulas to Remember