Scalar multiplication is not computed by literally adding the same point one by one.

For example, to compute:

we do not usually compute:

Instead, we use point doubling to reduce the number of operations.

For example:

and:

and:

So we can compute 5P like this:

1. Compute 2P
2. Compute 4P = 2P + 2P
3. Compute 5P = 4P + P

This takes fewer operations than adding P five times.

For very large values of k, efficient scalar multiplication uses double-and-add, an algorithm similar in spirit to repeated squaring. It reads the binary representation of the scalar from left to right: double the running point for each bit, then add $P$ when the bit is $1$.

For example:

Starting from $\mathcal{O}$, the steps are:

1. Read 1: $\mathcal{O} + P = P$
2. Read 1: double to $2P$, then add $P$ to get $3P$
3. Read 0: double to $6P$
4. Read 1: double to $12P$, then add $P$ to get $13P$

After initializing the running point as $P$, this computes $13P$ with three doublings and two further additions, rather than twelve point additions.

The number of required operations grows roughly with $\log_2 k$, instead of growing linearly with $k$.

This is important because finite-field scalar calculations use very large numbers.

If scalar multiplication required k individual additions, ECC would be unusable in practice.

Efficient scalar multiplication makes it practical to work with large scalars even though they represent many repeated point additions.