How Does GPS Work? Trilateration, Clocks and Relativity

Open a map on your phone and a blue dot shows where you are, usually to within a few metres. There is no signal from your phone to space, and the satellites do not know you exist. Your phone works out its own position by listening to satellites more than 20,000 km overhead and timing how long their signals take to arrive.

This guide explains how that works, step by step: distances from timing, finding a position from distances (called trilateration), why tiny clock errors matter so much, and why Einstein's relativity has to be built into the system. A short Python program does the same calculation your phone does, in two dimensions.

The satellites

The Global Positioning System, run by the United States, has around 31 operational satellites orbiting at a height of about 20,180 km, each going round the Earth in just under 12 hours. They are arranged so that almost anywhere on Earth, several are above the horizon at any time. Each carries very precise atomic clocks and continuously broadcasts its position and the exact time the signal left it. Other countries run similar systems, such as Europe's Galileo, and most phones use several at once.

Step 1: distance from time

Radio signals travel at the speed of light, 299,792,458 metres per second. If your phone knows when a signal left the satellite and when it arrived, it can work out the distance: distance = speed × time. A signal that took 0.07 seconds came from about 21,000 km away. But this means the timing has to be astonishingly accurate:

c = 299_792_458          # speed of light in metres per second

for name, seconds in [("1 nanosecond", 1e-9), ("1 microsecond", 1e-6), ("1 millisecond", 1e-3)]:
    print(f"a clock error of {name:<14} -> {c * seconds:>12,.1f} m of distance error")

# satellite clocks run fast by about 38 microseconds a day (relativity)
print(f"38 microseconds a day uncorrected -> {c * 38e-6 / 1000:.1f} km a day")

a clock error of 1 nanosecond   ->          0.3 m of distance error
a clock error of 1 microsecond  ->        299.8 m of distance error
a clock error of 1 millisecond  ->    299,792.5 m of distance error
38 microseconds a day uncorrected -> 11.4 km a day

An error of just one millionth of a second puts you 299.8 m out. That is why the satellites carry atomic clocks, and why the fourth satellite in the next section matters so much.

Step 2: position from distances (trilateration)

Knowing you are exactly 5 km from one tower does not tell you where you are: you could be anywhere on a circle of radius 5 km around it. A second distance narrows it to the two points where two circles cross. A third picks the right one. This is trilateration, and here it is in two dimensions, with three towers and a phone at a secret position:

import math

# Three towers at known positions (in km) and a phone somewhere between them
towers = [(0, 0), (10, 0), (4, 8)]
true_position = (6, 3)
distances = [math.dist(t, true_position) for t in towers]
if __name__ == "__main__":
    print("measured distances:", ", ".join(f"{d:.3f} km" for d in distances))

def locate(towers, d):
    """Subtract the circle equations to get two straight-line equations, then solve."""
    (x1, y1), (x2, y2), (x3, y3) = towers
    a1, b1 = 2 * (x2 - x1), 2 * (y2 - y1)
    c1 = d[0]**2 - d[1]**2 - x1**2 + x2**2 - y1**2 + y2**2
    a2, b2 = 2 * (x3 - x1), 2 * (y3 - y1)
    c2 = d[0]**2 - d[2]**2 - x1**2 + x3**2 - y1**2 + y3**2
    det = a1 * b2 - a2 * b1
    return (c1 * b2 - c2 * b1) / det, (a1 * c2 - a2 * c1) / det

if __name__ == "__main__":
    x, y = locate(towers, distances)
    print(f"position found: ({x:.3f}, {y:.3f})")

measured distances: 6.708 km, 5.000 km, 5.385 km
position found: (6.000, 3.000)

The neat trick in locate is that subtracting one circle's equation from another cancels the x² and y² terms, leaving a straight-line equation. Two such lines give two ordinary simultaneous equations, which the last three lines solve. The program recovers the position exactly. In three dimensions, circles become spheres, but the idea is identical.

Real measurements are never perfect

Signals are slowed slightly by the atmosphere, bounce off buildings and arrive a little late. So in practice each distance is a bit wrong. We added errors of 100 to 300 metres to the three distances:

import math
from trilat import towers, true_position, distances, locate

errors = [0.2, -0.3, 0.1]                 # each distance off by a few hundred metres
noisy = [d + e for d, e in zip(distances, errors)]
x, y = locate(towers, noisy)
print(f"with noisy distances: ({x:.3f}, {y:.3f})")
print(f"off by {math.dist((x, y), true_position) * 1000:.0f} m")

with noisy distances: (6.282, 2.961)
off by 284 m

Now the three circles do not meet at a single point, and the calculated position is 284 m from the truth. Real receivers use more satellites than the minimum and combine all the measurements in a best-fit calculation, which averages out much of the error. That is one reason your position is usually far better than this toy example.

Why the positions of the satellites matter

Trilateration works best when the reference points are spread out. Put the three towers in a straight line and something strange happens: a point above the line and its mirror image below it are exactly the same distances from all three.

import math
from trilat import locate

# Three towers in a straight line: a phone above the line and its mirror image below
towers = [(0, 0), (5, 0), (10, 0)]
above, below = (6, 3), (6, -3)
print("distances from above:", [round(math.dist(t, above), 3) for t in towers])
print("distances from below:", [round(math.dist(t, below), 3) for t in towers])
try:
    locate(towers, [math.dist(t, above) for t in towers])
except ZeroDivisionError:
    print("locate() fails: the equations cannot tell the two points apart")

distances from above: [6.708, 3.162, 5.0]
distances from below: [6.708, 3.162, 5.0]
locate() fails: the equations cannot tell the two points apart

Why four satellites, not three

Your phone does not have an atomic clock. Its clock is cheap and can be off by far more than a microsecond, which on its own would ruin every distance. The solution is elegant: treat the phone's clock error as an unknown to solve for, alongside the three coordinates of your position.

Four unknowns need four equations, so a receiver needs signals from at least four satellites. With four or more, it can work out both where it is and exactly what time it is. This is why GPS is also used to synchronise clocks in phone networks and power grids.

The relativity correction

Here is the part that surprises most people. According to Einstein's theories of relativity, clocks moving fast run slow, and clocks in weaker gravity run fast. The satellites are moving at several kilometres per second, which slows their clocks, but they are far from Earth's gravity, which speeds them up more. Overall, the satellite clocks gain about 38 microseconds a day compared with clocks on the ground. From the timing table, that would add up to roughly 11.4 km of error every day if nobody corrected for it. The system is designed with the correction built in, so relativity is not just theory: it is part of every map you open.

GPS in your phone, today

• Several systems at once: most phones combine GPS with Galileo, GLONASS and BeiDou, so there are more satellites to use.
• Help from the network: phones use nearby Wi-Fi and mobile masts to get a first rough fix quickly.
• Indoors and in cities: signals are blocked or bounce off buildings, which is why the blue dot sometimes jumps around.
• One-way: your phone only receives. The satellites never know you are there.

Your phone finds itself by timing light, solving simultaneous equations and allowing for relativity, many times a second.

How we teach it

GPS is a good example of a principle on our how we teach page: learning by building. Coding trilateration yourself turns circles, distances and simultaneous equations into something you can see working, and students explain their thinking as they connect each step to the maths behind it. Our live maths classes and coding courses run one to one or in small groups of 5 to 10.

Frequently asked questions