Euler's Identity

The identity

Euler's identity is:

e^(iπ) + 1 = 0

Or equivalently:

e^(iπ) = -1

It contains five of the most important mathematical constants:

• 0 — additive identity (the "do nothing" of addition).
• 1 — multiplicative identity (the "do nothing" of multiplication).
• π ≈ 3.14159... — the ratio of a circle's circumference to its diameter.
• e ≈ 2.71828... — base of the natural exponential, the "natural" growth rate.
• i = √(−1) — the imaginary unit.

And three operations — addition, multiplication, exponentiation. All in one equation. This is why Euler's identity is often called "the most beautiful equation in mathematics."

Euler's formula — the source

Euler's identity is a special case of Euler's formula:

e^(ix) = cos x + i sin x

For any real number x. Setting x = π:

e^(iπ) = cos π + i sin π = −1 + i·0 = −1

So e^(iπ) = −1, which rearranges to e^(iπ) + 1 = 0.

Proof via Taylor series

The Taylor series of e^z, cos x, and sin x:

e^z = 1 + z + z²/2! + z³/3! + z⁴/4! + z⁵/5! + ...
cos x = 1 − x²/2! + x⁴/4! − x⁶/6! + ...
sin x = x − x³/3! + x⁵/5! − x⁷/7! + ...

Substituting z = ix into e^z:

e^(ix) = 1 + ix + (ix)²/2! + (ix)³/3! + (ix)⁴/4! + (ix)⁵/5! + ...
       = 1 + ix − x²/2! − ix³/3! + x⁴/4! + ix⁵/5! − ...
       = (1 − x²/2! + x⁴/4! − ...) + i(x − x³/3! + x⁵/5! − ...)
       = cos x + i sin x

Powers of i cycle — i⁰ = 1, i¹ = i, i² = −1, i³ = −i, i⁴ = 1, ... — which produces the cos/sin separation when grouped by even/odd powers.

Geometric meaning — rotation

The complex number e^(iθ) lies on the unit circle at angle θ from the positive real axis (measured counterclockwise).

θ	e^(iθ)	Position on unit circle
0	1	Positive real axis
π/2	i	Positive imaginary axis
π	−1	Negative real axis
3π/2	−i	Negative imaginary axis
2π	1	Back to start (full rotation)

Multiplying any complex number z by e^(iθ) rotates z by θ around the origin. This makes Euler's formula a clean encoding of 2D rotation.

Applications across math and science

Signal processing — Fourier analysis

The Fourier transform decomposes a function f(t) into a sum of complex exponentials:

f(t) = ∫ F(ω) e^(iωt) dω

Each component e^(iωt) is a pure sinusoid at frequency ω. Manipulating signals via Fourier (filtering, compression, modulation) reduces to multiplying / shifting / scaling the Fourier coefficients. JPEG compression, MP3 audio, MRI imaging, all rely on this.

Quantum mechanics — phase

Quantum state evolution:

|ψ(t)⟩ = e^(−iHt/ℏ) |ψ(0)⟩

The complex exponential of the Hamiltonian H times time t gives the unitary evolution operator. All quantum interference, superposition, and entanglement effects depend on this.

Electrical engineering — AC circuits

AC voltage V(t) = V₀ cos(ωt + φ) is rewritten as V(t) = Re(V₀ e^(i(ωt + φ))). Differentiation and integration become multiplication by iω and 1/(iω). Circuit analysis simplifies dramatically.

Geometry — De Moivre's theorem

(cos θ + i sin θ)^n = cos(nθ) + i sin(nθ)

Equivalent to (e^(iθ))^n = e^(inθ). Used to derive multiple-angle formulas, find nth roots of unity, and solve polynomial equations.

JavaScript — Euler's formula in code

// Complex number class
class Complex {
  constructor(real, imag) {
    this.re = real;
    this.im = imag;
  }
  
  static fromPolar(magnitude, angle) {
    return new Complex(magnitude * Math.cos(angle), magnitude * Math.sin(angle));
  }
  
  multiply(other) {
    return new Complex(
      this.re * other.re - this.im * other.im,
      this.re * other.im + this.im * other.re
    );
  }
  
  toString() {
    return `${this.re.toFixed(4)} + ${this.im.toFixed(4)}i`;
  }
}

// Compute e^(ix) for various x
function eulerFormula(x) {
  return new Complex(Math.cos(x), Math.sin(x));
}

console.log(eulerFormula(0));            // 1.0000 + 0.0000i (e^0 = 1)
console.log(eulerFormula(Math.PI / 2));  // 0.0000 + 1.0000i (e^(iπ/2) = i)
console.log(eulerFormula(Math.PI));      // -1.0000 + 0.0000i (e^(iπ) = -1)
console.log(eulerFormula(2 * Math.PI));  // 1.0000 + 0.0000i (e^(2iπ) = 1, full rotation)

// Verify Euler's identity
const eulerIdentity = eulerFormula(Math.PI);
const sum = new Complex(eulerIdentity.re + 1, eulerIdentity.im);
console.log(`e^(iπ) + 1 = ${sum.toString()}`);  // ~ 0 + 0i ✓

// Rotation via complex multiplication
function rotatePoint(x, y, angle) {
  const z = new Complex(x, y);
  const rot = eulerFormula(angle);
  const result = z.multiply(rot);
  return [result.re, result.im];
}

console.log(rotatePoint(1, 0, Math.PI / 2));  // [~0, 1] (90° rotation)
console.log(rotatePoint(1, 0, Math.PI));      // [-1, 0] (180° rotation)

Where Euler's identity shows up

• Complex analysis. Foundation of complex-variable calculus. Cauchy's integral formula, residue theorem, conformal mapping all use e^(iθ) parameterizations.
• Fourier analysis and signal processing. Decomposing signals into complex exponentials. Audio, image processing, MRI, radar, sonar — all use e^(iωt).
• Quantum mechanics. Schrödinger evolution, quantum gates, interference, all use complex exponentials. Without them, quantum mechanics would be unwieldy.
• Electrical engineering. AC circuit analysis with phasors. Impedance, frequency response, transfer functions — all written in complex exponentials.
• Computer graphics — rotation and animation. 2D rotations via complex multiplication. Quaternions (4D) extend this to 3D rotation, used in game engines.
• Number theory. Roots of unity (e^(2πi/n)) generate cyclic groups. Used in Fast Fourier Transform, primality testing, lattice problems.
• Pure math foundations. Euler's identity is often the first "wow" moment for math students; bridges algebra, geometry, analysis, and complex numbers.

Common mistakes

• Treating e^(ix) as just "complex exponential." It's deeply geometric — points on the unit circle. The exponential interpretation works (formal Taylor series), but the rotation interpretation is what makes it useful.
• Confusing e^(iπ) with e^π · i. e^(iπ) = −1; e^π ≈ 23.14, multiplied by i = ~23.14i. Exponent placement matters.
• Thinking "i" is fictional or meaningless. i is as real as any other number — it's just orthogonal to the real axis. Complex numbers form a complete, well-defined algebraic system.
• Missing the negative sign in e^(iπ) = −1. The full identity adds 1 to get 0; if you write e^(iπ) = 1, you're off by a full rotation (e^(2iπ) = 1, not e^(iπ)).
• Mixing degrees and radians. Euler's formula uses radians — e^(iπ) means π radians = 180°. e^(180i) is something different (and very large in magnitude!).
• Forgetting that e^(iθ) has magnitude 1. |e^(iθ)| = √(cos²θ + sin²θ) = 1. Rotations preserve magnitude; only the angle changes.