Gaussian Integers

01What the Gaussian Integers Are

A Gaussian integer is a complex number whose real and imaginary parts are both ordinary integers: \(a+bi\) with \(a,b\in\mathbb{Z}\). Plotted in the complex plane, they are exactly the corners of the unit grid — a perfect square lattice.

They are closed under addition, subtraction, and multiplication, so they form a commutative ring with identity \(1\), written \(\mathbb{Z}[i]\). Addition is componentwise; multiplication uses \(i^2=-1\):

There are no zero divisors (a product is zero only if a factor is), so \(\mathbb{Z}[i]\) is an integral domain. Geometrically, multiplication is the complex-plane move you may know: lengths multiply and angles add. The widget below lets you feel that — drag the two points and switch between sum and product.

02The Norm — the Master Tool

Almost everything about \(\mathbb{Z}[i]\) is controlled by a single function, the norm, which sends a Gaussian integer to an ordinary non-negative integer:

It is the squared distance from the origin. Its superpower is that it is multiplicative — it turns multiplication in \(\mathbb{Z}[i]\) into multiplication in \(\mathbb{Z}\), letting us drag hard problems down to familiar integer arithmetic.

03Conjugates, Units & Associates

The conjugate \(\overline{a+bi}=a-bi\) is the mirror image across the real axis, and \(z\bar z=N(z)\). A unit is a Gaussian integer with a multiplicative inverse inside \(\mathbb{Z}[i]\). In the ordinary integers the only units are \(\pm1\); here there are exactly four.

Two Gaussian integers are associates if they differ by a unit — i.e. \(z\) and \(uz\) for \(u\in\{1,-1,i,-i\}\). Multiplying by \(i\) is a \(90^\circ\) rotation, so every Gaussian integer has four associates arranged as a little pinwheel around the origin. Factorization is only ever unique "up to units and order," exactly as \(6=2\cdot3=(-2)(-3)\) in \(\mathbb{Z}\).

04Divisibility & the Division Algorithm

We say \(\beta\) divides \(\alpha\) if \(\alpha=\beta\gamma\) for some Gaussian integer \(\gamma\). The decisive fact — the engine behind unique factorization — is that \(\mathbb{Z}[i]\) supports division with a small remainder, just like \(\mathbb{Z}\). This makes it a Euclidean domain, with the norm as its size function.

The geometry is the whole proof: the multiples of \(\beta\) form a scaled, rotated copy of the lattice, and every point of the plane lies within distance \(|\beta|/\sqrt2\) of some multiple \(\beta q\) — within the circle drawn below. That bound is exactly \(N(r)\le N(\beta)/2\).

05Why Factorization Is Unique

The division algorithm sets off a chain of consequences, each a standard theorem of ring theory:

That is: because we can divide with remainder, the Euclidean algorithm computes greatest common divisors; every ideal is generated by a single element (a principal ideal domain); and from there, every nonzero non-unit factors into primes uniquely, up to order and unit multiples (a unique factorization domain).

So we may speak of Gaussian primes — the irreducible building blocks — and know that every Gaussian integer is a product of them in essentially one way. The next section says exactly what those primes are.

06Gaussian Primes, Classified

A Gaussian integer \(\pi\) (not \(0\), not a unit) is a Gaussian prime if its only divisors are units and associates of itself. The complete list comes in three flavours, and the norm tells them apart.

Plotted in the plane, the Gaussian primes form a famously beautiful pattern with full 8-fold symmetry (reflections plus the \(90^\circ\) rotations from multiplying by \(i\)). Explore it — click any dot for its norm and type.

07Fermat's Two-Square Theorem

Here is the payoff — a 350-year-old gem about ordinary integers that falls out almost for free once you have Gaussian primes.

The full sum-of-two-squares theorem extends this to every positive integer: \(n\) is a sum of two squares iff every prime \(\equiv3\pmod4\) in its factorization appears to an even power. (Reason: such primes are inert, so they can only enter a Gaussian factorization in conjugate-free pairs.) Try numbers below and watch the rule decide.

08GNU Octave — Verified Code

Octave handles complex numbers natively (use 1i for the imaginary unit so it can't be shadowed by a variable). Every snippet ran in GNU Octave 8.4; the output is the real result.

The norm, and its multiplicativity

N = @(z) round(real(z)).^2 + round(imag(z)).^2;   % Gaussian norm

z = 3 + 2i;   w = 1 + 4i;
printf("N(z)=%d  N(w)=%d  N(z)*N(w)=%d\n", N(z), N(w), N(z)*N(w));
printf("z*w = %s   N(z*w) = %d\n", num2str(z*w), N(z*w));

Units are the four norm-1 elements

N = @(z) round(real(z)).^2 + round(imag(z)).^2;
for u = [1, -1, 1i, -1i, 2, 1+1i]
  printf("  %-5s  N=%d  unit? %d\n", num2str(u), N(u), N(u)==1);
end

Division algorithm & Euclidean gcd

function [q, r] = gdiv(a, b)
  q = round(real(a/b)) + 1i*round(imag(a/b));   % nearest Gaussian integer
  r = a - b*q;                                   % guaranteed N(r) < N(b)
end

function g = ggcd(a, b)
  while round(real(b))^2 + round(imag(b))^2 ~= 0    % while b is nonzero
    [~, r] = gdiv(a, b);
    a = b;  b = r;
  end
  g = a;                                          % gcd, defined up to a unit
end

Classifying Gaussian primes

function tf = gisprime(z)
  a = abs(round(real(z)));  b = abs(round(imag(z)));
  n = a^2 + b^2;
  if n <= 1
    tf = false;                       % 0 and the units are not primes
  elseif a == 0 || b == 0
    p = max(a, b);                    % a real/imaginary integer
    tf = isprime(p) && mod(p,4) == 3; % inert primes p = 3 (mod 4)
  else
    tf = isprime(n);                  % norm is a rational prime
  end
end

An ASCII map of the prime constellation

R = 8;                          % print '#' at every Gaussian prime
for b = R:-1:-R
  line = "";
  for a = -R:R
    if a==0 && b==0,            line = [line "+"];
    elseif gisprime(a + b*1i),  line = [line "#"];
    else                        line = [line "."];
    end
  end
  printf("%s\n", line);
end

Fermat: write a prime as a sum of two squares

function [a, b] = twosq(p)
  x = [];                              % find x with x^2 = -1 (mod p)
  for t = 2:p-1
    if mod(t*t + 1, p) == 0, x = t; break; end
  end
  g = ggcd(p, x + 1i);                 % gcd(p, x+i): a Gaussian prime of norm p
  a = abs(round(real(g)));  b = abs(round(imag(g)));
end

for p = [5 13 17 29 97 101]
  [a,b] = twosq(p);
  printf("  %3d = %d^2 + %d^2\n", p, a, b);
end

Bonus — Pythagorean triples from \((m+ni)^2\)

% Squaring a Gaussian integer manufactures a Pythagorean triple,
% because N((m+ni)^2) = (m^2+n^2)^2 is a perfect square.
for mn = [2 1; 3 2; 4 1]'
  m = mn(1);  n = mn(2);
  z = (m + n*1i)^2;
  A = abs(round(real(z)));  B = abs(round(imag(z)));  C = m^2 + n^2;
  printf("  (%d+%di)^2 -> (%d, %d, %d)\n", m, n, A, B, C);
end

09Applications & Wonders

Every primitive Pythagorean triple comes from one Gaussian integer

If \(m>n>0\) are coprime of opposite parity, then \((m+ni)^2=(m^2-n^2)+2mn\,i\) has norm \((m^2+n^2)^2\), so \((m^2-n^2,\,2mn,\,m^2+n^2)\) is a Pythagorean triple — and every primitive triple arises this way exactly once. Pythagoras, hiding inside complex multiplication.

The Gaussian moat problem

Can you walk from the origin to infinity stepping only on Gaussian primes, with bounded step size? Unlike the rational primes (where arbitrarily long prime gaps are known), this is open: nobody knows whether the primes thin out enough to leave an uncrossable "moat." It is a rare elementary-sounding question still unsolved.

Beyond \(i\): other rings of integers

\(\mathbb{Z}[i]\) is the first of the rings of integers of number fields. Its cousin \(\mathbb{Z}[\omega]\) (Eisenstein integers, \(\omega=e^{2\pi i/3}\)) tiles the plane with triangles and governs sums of the form \(a^2+ab+b^2\). Not all such rings enjoy unique factorization — the failure of it in \(\mathbb{Z}[\sqrt{-5}]\) (where \(6=2\cdot3=(1+\sqrt{-5})(1-\sqrt{-5})\)) is what launched the modern theory of ideals.

· i · −1 · −i · 1 ·