Pole-zero analysis for stability in Signal Processing - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Stability from Pole Locations

In discrete-time signal processing, which condition on the poles of a system's transfer function ensures the system is stable?

A All poles lie on the real axis regardless of their magnitude.

B All poles lie on or outside the unit circle in the complex plane.

C All poles lie strictly outside the unit circle in the complex plane.

D All poles lie strictly inside the unit circle in the complex plane.

💡 Hint

Think about where poles must be located so that the system's response does not grow over time.

For discrete-time systems, stability requires all poles to be inside the unit circle (magnitude less than 1). Poles outside or on the unit circle cause instability or marginal stability.

❓ Predict Output

intermediate

Identify Stable System from Poles

Given the poles of a system as complex numbers, which set corresponds to a stable system?

Signal Processing

poles_sets = {
    'A': [0.5 + 0.5j, 0.3 - 0.4j],
    'B': [1.0 + 0j, 0.8 + 0.1j],
    'C': [1.1 + 0j, 0.9 - 0.2j],
    'D': [0.9 + 0.9j, 0.7 + 0j]
}

# Which set is stable?

A Set A

B Set D

C Set C

D Set B

💡 Hint

Check if all poles have magnitude less than 1.

Set A poles have magnitudes less than 1, so the system is stable. Set B has a pole exactly on the unit circle (magnitude 1), which is marginally stable. Set C has a pole outside the unit circle (magnitude > 1), unstable. Set D has a pole with magnitude sqrt(0.9^2 + 0.9^2) ≈ 1.27 > 1, unstable.

❓ data_output

advanced

Calculate Stability from Given Poles

Given the following poles of a discrete-time system, determine how many poles lie outside the unit circle.

Signal Processing

import numpy as np

poles = np.array([0.9 + 0.1j, 1.05 + 0j, 0.7 - 0.7j, 1.0 + 0j, 0.5 + 0j])
magnitudes = np.abs(poles)
outside_count = np.sum(magnitudes > 1)
outside_count

A 2

B 1

C 3

D 0

💡 Hint

Count poles with magnitude strictly greater than 1.

Poles magnitudes: 0.9+0.1j ≈ 0.905, 1.05+0j = 1.05, 0.7-0.7j ≈ 0.99, 1.0+0j = 1.0, 0.5+0j = 0.5. Only one pole (1.05) is outside the unit circle.

❓ visualization

advanced

Plot Poles and Determine Stability

Given the poles plotted on the complex plane, which statement about system stability is correct?

The unit circle is shown as a dashed line.

Signal Processing

import matplotlib.pyplot as plt
import numpy as np

poles = np.array([0.8 + 0.6j, 0.9 - 0.1j, 1.1 + 0j, 0.5 + 0j])

fig, ax = plt.subplots()
unit_circle = plt.Circle((0, 0), 1, color='gray', fill=False, linestyle='dashed')
ax.add_artist(unit_circle)
ax.plot(poles.real, poles.imag, 'ro', label='Poles')
ax.set_xlim(-1.5, 1.5)
ax.set_ylim(-1.5, 1.5)
ax.set_aspect('equal')
ax.axhline(0, color='black', linewidth=0.5)
ax.axvline(0, color='black', linewidth=0.5)
ax.legend()
plt.show()

A The system is stable because all poles are inside the unit circle.

B The system is marginally stable because all poles lie on the unit circle.

C The system is unstable because at least one pole lies outside the unit circle.

D The system's stability cannot be determined from the plot.

💡 Hint

Look for any pole outside the dashed circle.

One pole at 1.1 + 0j lies outside the unit circle, making the system unstable.

🚀 Application

expert

Determine System Stability from Transfer Function Coefficients

Given the transfer function denominator coefficients of a discrete-time system:

den = [1, -1.5, 0.7]

Which statement about the system's stability is correct?

A The system is unstable because at least one pole has magnitude greater than 1.

B The system is stable because all poles have magnitude less than 1.

C The system is marginally stable because a pole lies exactly on the unit circle.

D The system's stability cannot be determined without numerator coefficients.

💡 Hint

Find the roots of the denominator polynomial and check their magnitudes.

Roots of the polynomial 1 - 1.5z + 0.7z^2 are approximately 1.071 and 0.654. The root at approximately 1.071 is outside the unit circle, making the system unstable.

Practice

1. What does the location of poles inside the unit circle on a pole-zero plot indicate about a system's stability?

easy

A. The system is stable

B. The system is unstable

C. The system is marginally stable

D. The system has no poles

Solution

1. Step 1: Understand pole location and stability

   Poles inside the unit circle mean the system's response decays over time.

2. Step 2: Relate pole location to system behavior

   Since poles are inside the unit circle, the system output will not grow unbounded.

3. Final Answer:

   The system is stable -> Option A

4. Quick Check:

   Poles inside unit circle = stable system [OK]

Hint: Poles inside unit circle mean stability [OK]

Common Mistakes:

• Confusing poles inside with outside the unit circle
• Thinking zeros affect stability directly
• Ignoring the unit circle boundary

2. Which of the following is the correct Python syntax to plot poles and zeros using matplotlib for a system with poles at [0.5+0.5j, 0.5-0.5j] and zeros at [0.8]?

easy

A. plt.scatter([0.5, 0.5], [0.5, -0.5], marker='x', color='r'); plt.scatter([0.8], [0], marker='o', color='b')

B. plt.plot([0.5, 0.5], [0.5, -0.5], 'ro'); plt.plot([0.8], [0], 'bo')

C. plt.scatter([0.5, 0.5], [0.5, -0.5], marker='o', color='b'); plt.scatter([0.8], [0], marker='x', color='r')

D. plt.plot([0.5, 0.5], [0.5, -0.5], 'bx'); plt.plot([0.8], [0], 'ro')

Solution

1. Step 1: Identify correct markers for poles and zeros

   Poles are usually marked with 'x' in red, zeros with 'o' in blue.

2. Step 2: Match syntax with matplotlib scatter function

   plt.scatter([0.5, 0.5], [0.5, -0.5], marker='x', color='r'); plt.scatter([0.8], [0], marker='o', color='b') uses plt.scatter with correct markers and colors for poles and zeros.

3. Final Answer:

   plt.scatter([0.5, 0.5], [0.5, -0.5], marker='x', color='r'); plt.scatter([0.8], [0], marker='o', color='b') -> Option A

4. Quick Check:

   Correct markers and colors for poles and zeros [OK]

Hint: Poles = red 'x', zeros = blue 'o' in plots [OK]

Common Mistakes:

• Swapping markers for poles and zeros
• Using plt.plot with wrong format strings
• Plotting zeros at wrong coordinates

3. Given the poles at [0.9, 1.1] and zeros at [0.5], what will be the stability status of the system?

medium

A. Stable because one pole is inside the unit circle

B. Stable because zeros are inside the unit circle

C. Marginally stable because poles are on the unit circle

D. Unstable because one pole is outside the unit circle

Solution

1. Step 1: Check each pole's location relative to the unit circle

   One pole is at 0.9 (inside), the other at 1.1 (outside) the unit circle.

2. Step 2: Determine stability from pole locations

   Since a pole lies outside the unit circle, the system is unstable regardless of zeros.

3. Final Answer:

   Unstable because one pole is outside the unit circle -> Option D

4. Quick Check:

   Any pole outside unit circle = unstable [OK]

Hint: Any pole outside unit circle means unstable system [OK]

Common Mistakes:

• Ignoring poles outside the unit circle
• Confusing zeros with poles for stability
• Assuming zeros affect stability directly

4. The following Python code attempts to plot poles and zeros but produces an error. What is the error and how to fix it?

import matplotlib.pyplot as plt
poles = [0.7+0.7j, 0.7-0.7j]
zeros = [0.9]
plt.scatter(poles.real, poles.imag, marker='x', color='r')
plt.scatter(zeros.real, zeros.imag, marker='o', color='b')
plt.show()

medium

A. Error because marker symbols are incorrect

B. Error because poles and zeros are lists, need numpy arrays for .real and .imag

C. Error because plt.show() is missing

D. No error, code runs fine

Solution

1. Step 1: Identify data types of poles and zeros

   Poles and zeros are Python lists of complex numbers, which do not support .real or .imag attributes directly.

2. Step 2: Fix by converting lists to numpy arrays

   Convert poles and zeros to numpy arrays to access .real and .imag properties without error.

3. Final Answer:

   Error because poles and zeros are lists, need numpy arrays for .real and .imag -> Option B

4. Quick Check:

   Lists lack .real/.imag; use numpy arrays [OK]

Hint: Use numpy arrays for complex .real and .imag access [OK]

Common Mistakes:

• Trying to access .real on Python lists
• Ignoring missing plt.show()
• Using wrong marker symbols

5. You have a discrete-time system with poles at [0.6, 0.8*1j, -0.8*1j] and zeros at [0.9]. You want to improve stability by moving poles closer to the origin without changing zeros. Which pole movement will make the system more stable?

hard

A. Move poles to [0.6, 0.8j, -0.8j] (no change)

B. Move poles to [1.1, 0.9j, -0.9j]

C. Move poles to [0.4, 0.5j, -0.5j]

D. Move poles to [0.7, 0.85j, -0.85j]

Solution

1. Step 1: Understand stability and pole radius

   Poles closer to origin (smaller magnitude) mean faster decay and better stability.

2. Step 2: Compare given pole movements

   Move poles to [0.4, 0.5j, -0.5j] moves poles closer to origin (0.4 and 0.5j), reducing magnitude from original values.

3. Step 3: Confirm other options increase or keep magnitude same

   Options B and C move poles farther or slightly farther from origin, reducing stability; A is no change.

4. Final Answer:

   Move poles to [0.4, 0.5j, -0.5j] -> Option C

5. Quick Check:

   Smaller pole radius = better stability [OK]

Hint: Move poles closer to origin to improve stability [OK]

Common Mistakes:

• Moving poles outside unit circle
• Changing zeros instead of poles
• Not reducing pole magnitude