Static and Dynamic Systems

Main ideas / lessons

This lecture explains static vs. dynamic systems by focusing on how the system output (y_t) relates to the input values at:

• Past time ((x_{t-1}))
• Present time ((x_t))
• Future time ((x_{t+1}))

A key modeling idea is that the input sequence is not changed; the “shift” (e.g., (x_{t-1}) or (x_{t+1})) happens due to the system’s relationship, not because the input itself changes.

The discussion uses a block notation: input is (x_t), output is (y_t), and the system is represented abstractly by a block. The system’s nature is inferred from the output-input formula.

Notation introduced

• Input: (x_t)
• Output: (y_t)
• System: represented by a block
• Past/present/future dependence is central to classification.

How past/present/future dependence is illustrated

Three cases:

1. Past input case: [ y_t = x_{t-1} ]

2. Present input case: [ y_t = x_t ]

3. Future input case: [ y_t = x_{t+1} ]

Important clarification (about delays/shifts)

When a system outputs something like (y_t = x_{t-1}), it does not mean the input becomes (x_{t-1}).

The input is still the original (x_t) sequence; the system produces an output that depends on a shifted time index (past or future) due to the system behavior.

Example signal values given

They assign values to (x_t):

• (x_{-2} = 1.5)
• (x_{-1} = 2.0)
• (x_{0} = 2.5)
• (x_{1} = 3.0) (and a “zero” value is mentioned, likely as (x_2) or a related value, though the transcription is unclear)

They feed these into a system (considering case 1 only) where:

• System rule: (y_t = x_{t-1})

Computation shown (using (y_t = x_{t-1}))

• For (t=0): [ y_0 = x_{-1} = 2.0 ]

Contrast with a buffer-like system (y_t = x_t), which would give:

[ y_0 = x_0 = 2.5 ]

Lesson: the output value at time (t) can come from a different time index because of the system’s dependence on past inputs (delay).

Definitions: Static vs. Dynamic systems

Static system

Definition: The output depends only on present values of input (at any instant of time).

Example given:

• [ y_t = 2x_t ]

How to verify (method suggested):

• Check with specific time instants such as (t=0,1,2,\dots); if the output uses only (x_t), it is static.
• The lecturer warns that checking only one time (like (t=0)) might mislead if it’s actually dynamic—so generally test across time indices in exams.

Dynamic system

Definition: The output depends on past and/or future values of input (at any instant of time).

Output dependence on past or future makes it dynamic, even if it also depends on present.

Example given:

• [ y_t = x_t + x_{t-1} ] Because (x_{t-1}) is past input, this is dynamic.

Practice / example problems discussed

Two examples are mentioned, but only the second is analyzed in detail; the first is left as homework.

Example / Homework (Problem 1)

• Given: [ y_t = x_{t+1} + x_t ]

• Status: marked as homework for the viewer.

Problem 2 (solved in lecture)

• Given: [ y_t = e^{-t+1}\cdot x_t ]

Key common mistake addressed:

• Seeing (t+1) might tempt you to think output depends on future input.
• Clarification:
  • (e^{-t+1}) is just a coefficient (a multiplier), not an input shift.

Classification reasoning:

• The only input term is (x_t) (present input).
• Therefore, the system is static.

Speakers / sources featured

• No named speakers or external sources are identified in the subtitles.
• The only apparent source is the lecture instructor/teacher delivering the content.