Pole-zero analysis for stability in Signal Processing - Step-by-Step Execution

Concept Flow - Pole-zero analysis for stability

Define system transfer function H(z)

↓

Find poles and zeros of H(z)

↓

Plot poles and zeros on z-plane

↓

Check pole locations relative to unit circle

↓

Determine system stability

↓

Stable if all poles inside unit circle

↓

Unstable if any pole on or outside unit circle

This flow shows how to analyze a system's stability by finding poles and zeros, plotting them, and checking if poles lie inside the unit circle.

Execution Sample

Signal Processing

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import tf2zpk

b = [0.5, -0.5]
a = [1, -0.8]
zeros, poles, _ = tf2zpk(b, a)

This code finds the zeros and poles of a system defined by numerator b and denominator a coefficients.

Execution Table

Step	Action	Input	Output	Notes
1	Define numerator coefficients b	[0.5, -0.5]	b = [0.5, -0.5]	Represents zeros polynomial
2	Define denominator coefficients a	[1, -0.8]	a = [1, -0.8]	Represents poles polynomial
3	Calculate zeros and poles using tf2zpk	b, a	zeros = [1.0], poles = [0.8]	Zeros at z=1, poles at z=0.8
4	Plot poles and zeros on complex plane	zeros, poles	Plot with zeros as 'o', poles as 'x'	Visual check of locations
5	Check if poles inside unit circle	poles = [0.8]	0.8 < 1 (inside unit circle)	System is stable
6	End	-	-	Poles inside unit circle, stability confirmed

💡 Execution stops after confirming all poles are inside the unit circle, indicating stability.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
b	undefined	[0.5, -0.5]	[0.5, -0.5]	[0.5, -0.5]	[0.5, -0.5]
a	undefined	undefined	[1, -0.8]	[1, -0.8]	[1, -0.8]
zeros	undefined	undefined	undefined	[1.0]	[1.0]
poles	undefined	undefined	undefined	[0.8]	[0.8]

Key Moments - 3 Insights

Why do we check if poles are inside the unit circle?

Because the system is stable only if all poles lie strictly inside the unit circle, as shown in step 5 of the execution_table.

What does a zero at z=1 mean for the system?

A zero at z=1 means the system output is zero at that frequency, but it does not affect stability, which depends only on poles (see step 3).

Can a pole on the unit circle be stable?

No, poles on or outside the unit circle cause instability or marginal stability; stability requires poles strictly inside, as confirmed in step 5.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what are the calculated poles?

A [0.5]

B [1.0]

C [0.8]

D [-0.8]

💡 Hint

Check the 'Output' column in step 3 of the execution_table.

At which step do we confirm the system is stable?

A Step 5

B Step 3

C Step 2

D Step 4

💡 Hint

Look for the step where poles are compared to the unit circle in the execution_table.

If a pole was at 1.2 instead of 0.8, what would change in the execution_table?

A Step 3 would show zeros changed

B Step 5 would show pole outside unit circle and system unstable

C Step 4 plot would not change

D No change in stability conclusion

💡 Hint

Consider the 'Check if poles inside unit circle' action in step 5.

Concept Snapshot

Pole-zero analysis checks system stability by:
- Finding poles and zeros from transfer function
- Plotting them on the complex z-plane
- Stability requires all poles inside the unit circle
- Zeros do not affect stability
- Poles on or outside unit circle mean instability

Full Transcript

Pole-zero analysis for stability involves defining the system's transfer function with numerator and denominator coefficients. We calculate zeros and poles using a function like tf2zpk. Then, we plot these on the complex plane to visualize their locations. The key step is checking if all poles lie inside the unit circle; if yes, the system is stable. Zeros do not affect stability. If any pole lies on or outside the unit circle, the system is unstable. This process helps us understand and ensure system stability in signal processing.

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