Geometric Series: Formula, Convergence, and Examples

Ever wondered how 1 + 2 + 4 + 8 + ... can be expressed with a single, clean formula?

A series is just a sum of terms from a sequence. When those terms grow (or shrink) by multiplying each time by the same number, you've got a geometric series. That constant multiplier is called the common ratio, and it's what makes the whole thing work. 

Geometric series show up everywhere, from loan payments, signal decay, to algorithm analysis. Knowing how to work with them is a must-have math skill for anyone working with data.

In this article, I'll cover the key formulas, explain when an infinite geometric series actually has a finite sum, and walk through real examples.

If you know Python fundamentals, you’re ready to learn the interesting stuff. Enroll in our 16-hour-long Machine Learning Fundamentals in Python course.

What Is a Geometric Series?

A geometric series is a sum of terms where each term is obtained by multiplying the previous one by a constant ratio.

For example, take 1 + 2 + 4 + 8 + 16. Each term is double the one before it. That doubling factor is what makes it geometric.

There are two values define every geometric series:

• First term (a) - the starting value of the series
• Common ratio (r) - the constant multiplier applied to each term to get the next one

If a = 1 and r = 2, you get 1 + 2 + 4 + 8 + .... If a = 3 and r = 0.5, you get 3 + 1.5 + 0.75 + ... The structure is always the same.

That's the whole idea. Every geometric series is just repeated multiplication, starting from a and scaled by r at each step.

Geometric Sequence vs Geometric Series

These two terms get mixed up a lot, but the difference takes exactly one sentence to explain.

A geometric sequence is just a list of numbers: 1, 2, 4, 8, 16, while a geometric series is what you get when you add them up: 1 + 2 + 4 + 8 + 16 = 31.

The numbers are identical, but the operation is different. The sequence lists them, the series sums them.

Formula for a Finite Geometric Series

The sum of the first n terms of a geometric series is defined by this formula:

Sum of the first n terms formula

Where:

• a = the first term

• r = the common ratio

• n = the number of terms

Let's go through a simple example. Say you want to sum the first 4 terms of 1 + 2 + 4 + 8. Here, a = 1, r = 2, and n = 4.

Simple geometric series example

You can verify this by hand: 1 + 2 + 4 + 8 = 15. The formula gets you there in one step, which matters when n gets large.

Infinite Geometric Series and Convergence

Here's an unusual concept to wrap your head around: an infinite series can have a finite sum.

Take 1 + 0.5 + 0.25 + 0.125 + .... You could keep adding terms forever, but the total never exceeds 2. That's because each new term is smaller than the last - small enough that the sum settles toward a fixed value instead of growing without bound.

This behavior is called convergence, and it only happens under one condition: |r| < 1.

When the common ratio is between -1 and 1 (exclusive), each term shrinks as you move through the series. The terms approach zero, which means adding more of them contributes less and less to the total. The sum stabilizes.

If |r| ≥ 1, the terms don't shrink. They stay the same size or grow, and the sum just keeps increasing. That's a divergent series - it has no finite sum.

The absolute value bars around r is something to pay attention to. A ratio of -0.5 also converges, because the terms alternate in sign but still shrink toward zero.

Formula for Infinite Geometric Series

When |r| < 1, you can sum an infinite geometric series with a single formula:

Infinite geometric series formula

Where a is the first term and r is the common ratio. That's it - no n needed, because the series never stops.

Let's use the example from the previous section: 1 + 0.5 + 0.25 + 0.125 + .... Here, a = 1 and r = 0.5.

Infinite geometric series example

The infinite sum is exactly 2. You could add terms forever and never exceed it.

It’s important to note that this formula only works when |r| < 1. If the series diverges, the formula won’t work anymore and will give you a meaningless result. Remember to always check the convergence condition before applying it.

Why Convergence Matters

Not every infinite series settles on a finite sum. Some just keep growing.

Take 1 + 2 + 4 + 8 + .... Here r = 2, which means each term is larger than the one before it. The sum has no limit - it grows without bound. That's a divergent series, and applying the infinite sum formula to it gives you a meaningless result.

The same happens when r = 1. The series 3 + 3 + 3 + 3 + ... never stops accumulating, so there's no finite sum to speak of.

This is why checking |r| < 1 before reaching for the formula is mandatory. If the series diverges, the formula doesn't break in an obvious way - it just gives you a number that looks plausible but is completely wrong.

Geometric Series in Python

Let's put everything covered so far into code. I'll implement both the finite and infinite sum formulas, verify the results, and visualize how partial sums behave as we add more terms.

Finite geometric series

This is all the Python logic you need to implement the finite geometric series formula:

def finite_geometric_sum(a, r, n):
    if r == 1:
        return a * n
    return a * (1 - r**n) / (1 - r)

result = finite_geometric_sum(a=1, r=2, n=4)
print(f"Finite sum (a=1, r=2, n=4): {result}")

Finite geometric series in Python

Infinite geometric series

It’s a similar story for infinite series, you just need to raise an error if the constraint is violated:

def infinite_geometric_sum(a, r):
    if abs(r) >= 1:
        raise ValueError(f"Series diverges for |r| >= 1. Got r={r}.")
    return a / (1 - r)

# Example: 1 + 0.5 + 0.25 + ... (a=1, r=0.5)
result = infinite_geometric_sum(a=1, r=0.5)
print(f"Infinite sum (a=1, r=0.5): {result}")

Infinite geometric series in Python

The function raises an error when |r| >= 1 so you don't silently get a wrong answer.

Visualizing convergence

This is where it gets interesting. For a converging series, the partial sums should approach the theoretical limit as n grows. Let's plot that.

import numpy as np
import matplotlib.pyplot as plt

COLOR_DARK = "#1a1a2e"
COLOR_GREEN = "#03EF62"
COLOR_LIGHT_GRAY = "#cccccc"

a, r = 1, 0.5
n_terms = 30
theoretical_limit = infinite_geometric_sum(a, r)

# Compute partial sums
terms = a * r ** np.arange(n_terms)
partial_sums = np.cumsum(terms)

# Plot
fig, ax = plt.subplots(figsize=(10, 5), facecolor=COLOR_DARK)
ax.set_facecolor(COLOR_DARK)

ax.plot(range(1, n_terms + 1), partial_sums, color=COLOR_GREEN, linewidth=2, label="Partial sums")
ax.axhline(y=theoretical_limit, color=COLOR_LIGHT_GRAY, linewidth=1, linestyle="--", label=f"Limit = {theoretical_limit}")

ax.scatter(range(1, n_terms + 1), partial_sums, color=COLOR_LIGHT_GRAY, s=30, zorder=3)

# Style
for spine in ax.spines.values():
    spine.set_visible(False)
ax.spines["bottom"].set_visible(True)
ax.spines["bottom"].set_color(COLOR_LIGHT_GRAY)
ax.spines["bottom"].set_alpha(0.3)

ax.tick_params(colors=COLOR_LIGHT_GRAY)
ax.xaxis.label.set_color(COLOR_LIGHT_GRAY)
ax.yaxis.label.set_color(COLOR_LIGHT_GRAY)
ax.set_xlabel("Number of terms")
ax.set_ylabel("Partial sum")
ax.set_title("Convergence of geometric series (a=1, r=0.5)", color=COLOR_LIGHT_GRAY, pad=15)

legend = ax.legend(facecolor=COLOR_DARK, edgecolor=COLOR_LIGHT_GRAY, labelcolor=COLOR_LIGHT_GRAY)
legend.get_frame().set_alpha(0.3)

plt.tight_layout()
plt.show()

Converging series visualization

The partial sum goes toward 2.0 and flattens out, which is exactly what convergence looks like in practice. Each additional term contributes less than the last, and the curve settles on the theoretical limit.

Common Applications of Geometric Series

Geometric series model real patterns that show up across finance, physics, and computer science.

Finance is the most familiar example. When you invest money at a fixed interest rate, each period's balance is the previous one multiplied by a constant factor. The total value of those compounding returns over time is a geometric series. The same structure applies to loan amortization and annuity calculations.

Physics uses geometric series to model decay processes. Radioactive decay, signal attenuation, and energy dissipation all follow a pattern where each step reduces the quantity by a fixed ratio. You can think of the total amount of a substance that decays over infinite time as a converging geometric series.

In computer science, geometric series appear in algorithm analysis. Recursive algorithms that halve the problem size at each step - like binary search or merge sort - generate a geometric series when you count the total work done across all levels. They also show up in memory allocation schemes and data structure sizing strategies where capacity grows by a fixed multiplier.

Common Mistakes with Geometric Series

Most errors with geometric series come down to a couple of misread definitions and one bad formula application.

Confusing sequence with series

This is the most common one. A sequence is a list, a series is a sum. If someone asks for the "geometric series" and you list out the terms instead of summing them, you've answered the wrong question. The distinction especially matters when the answer is expected to be a single number.

Applying the infinite sum formula when |r| ≥ 1

This is a quiet mistake. The formula S = a / (1 - r) only works when the series converges. If you set r = 2 and get a tidy-looking number, that number is meaningless. Always check |r| < 1 first.

Misidentifying the common ratio

This one is trickier than it sounds. The ratio r is always the value you multiply by to get the next term - not the difference between terms, and not the first term divided by the second. With 3 + 6 + 12 + 24, the ratio is 2, not 3. Divide any term by the one before it to get r, and double-check with a couple of pairs to make sure it's actually constant.

Conclusion

A geometric series is repeated multiplication, summed up. Every term follows from the previous one by the same ratio, which is what makes the pattern predictable and the formulas easy to interpret.

The convergence condition - |r| < 1 - is the one thing you must remember. It's what separates a series with a meaningful finite sum from one that grows without bound. If you get that check wrong, the results you get won’t matter.

That's really all there is to it. Spot the ratio, check the convergence condition, apply the right formula. Nothing more to it.

If you find geometric series easy, read our recent Taylor Series: From Approximations to Optimization blog post - the math isn’t as simple, but explanations are just as clear.