De Moivre's theorem — common mistake

“Expanding (a+ib)⁵ by hand is like counting each grain of sand on a beach.”

Instead of binomial expansion, switch to polar form and apply De Moivre; this avoids messy algebra. The trap is forgetting to convert before raising, leading to wrong real-imag parts.

Memory trick: DeMoivre beats binomial

Roots of unity

“The 6th roots of unity are the six vertices of a perfect hexagon on a clock face.”

The n-th roots of 1 lie on the unit circle, equally spaced by 2π/n, forming a regular n-gon. Their vector sum is zero because they are symmetric about the origin. A pitfall is assuming the roots are only real numbers.

Memory trick: Unity roots = regular polygon

Roots of unity — common mistake

“Like a carousel with N equally spaced seats, the N-th roots of unity pull equally in all directions, cancelling out for N ≥ 2.”

The N-th roots are e^(2πik/N) (k=0…N-1). Their vector sum is 0 only when N≥2, because the roots form a regular polygon symmetric about the origin. A common trap is using the zero-sum rule for N=1, where the sole root is 1.

Memory trick: Zero sum only if more than one root (N>1).

Conjugate and its uses

“Seeing a glass reflected in a mirror keeps its height unchanged, just as a complex number and its conjugate share the same magnitude.”

The conjugate z̄ reflects z across the real axis. Multiplying z by z̄ gives |z|², a real number, and is used to rationalise denominators. A common trap is forgetting to multiply numerator and denominator by the conjugate, leaving a complex denominator.

Memory trick: z·z̄ = (Re)²+(Im)² = |z|²

Conjugate and its uses — common mistake

“A palindrome reads the same backward; similarly z and its conjugate have identical ‘length’ (modulus).”

Taking the conjugate flips the sign of the imaginary part but leaves the modulus unchanged: |z̄| = |z|. Students often think the modulus changes sign, leading to wrong magnitude calculations.

Memory trick: Modulus unchanged: |z| = |z̄|

Geometry of complex numbers

“Rotating a pizza slice on a turntable by 90° mirrors multiplying a complex number by i.”

Adding complex numbers is vector addition; multiplying by a+ib scales by √(a²+b²) and rotates by arg(a+ib). The trap is assuming multiplication only rotates—ignore the scaling factor r.

Memory trick: a+ib = r·e^(iθ): scale r, rotate θ

Geometry of complex numbers — common mistake

“Turning a key twice (180°) flips its teeth, just as i·i = -1 rotates a point by 180°.”

Multiplying by i rotates a point 90° counter-clockwise; doing it twice gives i² = -1, a 180° turn that also flips the sign. Forgetting the sign change after two i-rotations is a frequent error.

Memory trick: i² = -1 → two 90° turns = 180° flip

Euler's form

“A lighthouse beam sweeping a full circle is described by e^(iθ), linking rotation to exponentials.”

Euler’s formula e^(iθ)=cosθ+i sinθ represents points on the unit circle; its magnitude is 1 and the argument is θ. When using it for powers, keep the modulus r separate (r·e^(iθ)); ignoring this gives wrong magnitude.

Memory trick: e^(iθ)=cosθ+ i sinθ, unit circle

Euler's form — common mistake

“Stirring coffee continuously rotates the liquid, not the same as adding a spoonful of coffee; similarly e^(iθ) cannot be split into eⁱ·θ.”

The expression e^(iθ) is a single exponential; separating it as eⁱ·θ is incorrect and yields wrong trig values. The trap is treating θ as a factor rather than part of the exponent.

Memory trick: e^(iθ) ≠ eⁱ·θ; keep exponent together

|z| = sqrt(a^2 + b^2)

“Like measuring the diagonal of a rectangular kitchen tile using its side lengths a and b.”

The modulus of a+bi equals √(a²+b²) because it is the Euclidean distance from the origin. It is always non-negative, so the root is taken as +√, never ±. Toppers watch that even if a or b are negative, |z| stays ≥0.

|z| = sqrt(a² + b²)

Memory trick: Modulus = hypotenuse of (a,b) right-triangle.

(cos t + i sin t)^n = cos nt + i sin nt

“Like rotating a fan blade n times; each turn adds the same angle to the blade’s position.”

From the polar form z=cos t+i sin t, raising to integer n multiplies the angle: (cos t+i sin t)ⁿ=cos (nt)+i sin (nt). For negative n use the reciprocal, and always reduce nt modulo 2π before reading cosine or sine. Forgetting the reduction gives wrong sign.

(cos t + i sin t)ⁿ = cos nt + i sin nt

Memory trick: De Moivre: power → multiply angle.

z * conj(z) = |z|^2

“Like pairing a key with its mirror image; together they lock into a pure number.”

Multiplying z=a+bi by its conjugate a−bi yields a²+b², which equals |z|² – a real, non-negative value. This identity rationalises denominators. The trap is to multiply by the same sign (a+bi), giving a²−b²+2abi, not the modulus.

z * conj(z) = |z|²

Memory trick: Conjugate flips i→−i; product = a²+b².

n-th roots of unity: e^(2 pi i k/n)

“Like n equally spaced candles around a round cake.”

The equation zⁿ=1 has solutions e^(2πik/n) for k=0,…,n−1, points on the unit circle at angles 2πk/n. They are spaced by 2π/n. The common slip is letting k run to n, which repeats the root k=0.

n-th roots of unity: e^(2 pi i k/n)

Memory trick: Roots = unit-circle points every 360°/n.

e^(i theta) = cos theta + i sin theta

“Like a spinning wheel where one full turn (2π) matches a full cosine-sine cycle.”

Euler’s formula e^(iθ)=cosθ+i sinθ follows from series expansions and links exponential growth to circular motion. θ must be in radians; using degrees breaks the equality. Remember the series match only in radian measure.

e^(i theta) = cos theta + i sin theta

Memory trick: e^(iθ)=cosθ+ i sinθ, θ in rad.

|z1 z2| = |z1| |z2|

“If you first double a rope’s length and then triple it, the final rope is six times the original.”

For any complex numbers z1, z2, the modulus satisfies |z1z2| = |z1|·|z2| because |z| is the distance from the origin, and multiplication scales that distance by the product of the two scales. The identity also holds when a factor is zero. Beware: the arguments add, they do not multiply.

|z1 z2| = |z1| |z2|

Memory trick: Lengths multiply like rope stretches.

Cartesian form vs polar form

“Like adding two GPS vectors, you add their x-y components, but to rotate a point you multiply its distance and turn the angle.”

In Cartesian z = a+bi, addition/subtraction is component-wise, so it’s fastest. In polar z = r cisθ, multiplication/division and powers use r₁·r₂ and θ₁+θ₂ (or subtraction). The trap: after adding angles keep the result within (-π,π] or 0-2π; forgetting this gives a wrong argument.

Memory trick: Add/subtract in a+bi; multiply/divide in r cisθ.

modulus vs argument

“A ship’s distance from port is its modulus, while the bearing you steer is the argument.”

|z| = √(a²+b²) gives the radial distance; Arg(z) is the angle measured from the positive real axis, defined up to 2π. The trap: Arg is undefined for z = 0 and you must pick the correct quadrant when using arctan, otherwise the angle is off by π.

Memory trick: Mod = radius, Arg = bearing.

z vs its conjugate

“Seeing a number’s reflection in a calm lake flips its angle like a mirror image.”

z = r cisθ and its conjugate ̅z = r cis(-θ) have identical modulus r but opposite arguments. Their product z·̅z = r² is always a positive real. The trap: assuming the conjugate keeps the same angle leads to wrong sign in Arg calculations.

Memory trick: Conj = same r, opposite θ.

Memory trick: Product: r×r, θ+θ.

Arithmetic progression

“Climbing a ladder where each rung is exactly 5 cm higher than the previous one illustrates an arithmetic progression.”

In an AP each term aₙ = a₁ + (n-1)d, so the terms increase linearly. The sum of the first n terms is Sₙ = n/2[2a₁+(n-1)d]. A common trap is forgetting the brackets and writing n(2a₁+n-1)d/2, which changes the result.

Memory trick: AP = Add a constant d each step.

Arithmetic progression — common mistake

“When you fill a bucket, you add exactly 3 L each minute; the volume grows by a fixed amount, not by a factor.”

In an AP each term = previous term + d, so an = a1 + (n-1)d. The classic trap is treating the common difference as a ratio and using multiplication, which gives wrong results especially when terms become negative or zero.

Memory trick: AP = Add d each step; GP = Multiply by r

Geometric progression

“A leaking bucket fills slower each minute; the water added each minute is multiplied by r, and only if r<1 does it level off.”

For a GP a, ar, ar²,… the infinite sum S = a/(1-r) exists only when |r|<1, ensuring terms tend to zero. The classic trap is writing S = a/(1-r) without confirming |r|<1, especially with r = 1 or r = –1 where the series diverges.

Memory trick: Converge only if |r|<1 → ‘r’ under 1

Geometric progression — common mistake

“Assuming a bouncing ball that loses half its height each bounce will bounce forever uses the wrong r≥1 rule.”

A frequent error is applying S∞ = a/(1-r) when |r|≥1, which diverges. For r=1 the series is n·a, and for |r|>1 the terms grow without bound. Recognize the convergence condition before using the formula.

Memory trick: If |r|≥1 → no finite S∞.

Arithmetic-geometric series

“A staircase where each step’s height grows arithmetically while its width expands geometrically.”

An AGP term is T_n = (a+(n-1)d)·rⁿ⁻¹. For r≠1, S_n = a(1-rⁿ)/(1-r) + d·(r-n rⁿ + (n-1) rⁿ⁺¹)/(1-r)²; for r=1, S_n = n a + d·n(n-1)/2. The trap: applying only the GP telescoping part and omitting the extra d-term, which yields a wrong sum.

Memory trick: AGP = split A-rithmetic + G-eometric sums