Notebooks · posts/doubling-time-breaks-at-tiny-rates-and-at-negative-ones

Doubling time breaks at tiny rates and at negative ones

Adam Zettel · September 24, 2026 · written with an agent

An attempt to break the program in the post "Doubling time" (an adversarial review), posted as four tests that fail. At a rate of $1 0^{- 12}$ a year it is off by a relative $9 \times 1 0^{- 5}$ ; at $1 0^{- 16}$ it says the money never doubles; at $- 5%$ it says the money doubled 13.5 years ago; and the monthly formula has the same flaw once the additions are small enough. The program above the four tests is the reviewed one, with the formula for interest added $n$ times a year and its tests added.

ln (1 + r) with r = 1 0^{- 12} : 1 + r rounds first

This post copies the program it reviews, adds the formula for interest added $n$ times a year with its tests, and adds four tests at the bottom, one for each problem found. The site runs those four tests on the reviewed program and checks that each one fails there. To solve this problem, change the program so that all its tests pass.

The problems were found by giving doubling_time rates far from the 3% and 7% the original tests use, and comparing with $ln 2/ r$ , which for a small rate $r$ is off by a relative error of only about $r /2$ .

The small-rate failure comes from rounding; the formula is exact. A double carries about 16 digits, so the $1 0^{- 12}$ in $1 + 1 0^{- 12}$ is stored as $1.00009 \times 1 0^{- 12}$ , and the logarithm of the sum is off in its fifth digit. At $1 0^{- 16}$ the sum rounds to exactly 1, the logarithm is 0, and the division gives infinity. The usual cure is log1p, a logarithm of $1 + x$ that never forms $1 + x$ .

The program never checks for a negative rate: money that shrinks never doubles, and the formula returns a negative number of years instead of saying so.

Look inside this program

Atlas
The program’s map: every function and which calls which.
There’s no recorded run of this program yet.

This is a problem: its tests fail until the functions in it are written. Edit a cell and run it to try; the cells below it show whether the tests pass.

Shift+Enter in a cell runs it and moves to the next. Running a cell runs every cell above it too, as one program.

[1]lines 31–129

RATE = 0.07

#| Years to double at a yearly rate, with interest added once a year.
def doubling_time(rate) {
    "How many years until the amount is twice what it started as."
    return log(2.0) / log(1.0 + rate)
}
#| The rule of 70: divide 70 by the rate written as a percentage.
def rule_of_70(rate) {
    return 70.0 / (100.0 * rate)
}
#| Years to double when the yearly rate is split into `times` smaller additions.
def doubling_time_n(rate, times) {
    "Each addition is rate/times; there are `times` of them a year."
    return log(2.0) / (times * log(1.0 + rate / times))
}

# the answers the notes quote
t_double = doubling_time(RATE)
show t_double
show rule_of_70(RATE)
t_monthly = doubling_time_n(RATE, 12.0)
show t_monthly
t_continuous = log(2.0) / RATE
show t_continuous

# the picture: growth that compounds, against growth that does not
# a point every quarter year for twenty years
N_TIMES = 81
ts = linspace(0.0, 20.0, N_TIMES)
figure("Growth at 7% a year, compounding and not", "years", "amount, starting from 1")
plot(ts, exp(log(1.0 + RATE) * ts), "$1.07^t$")
plot(ts, 1.0 + RATE * ts, "1 + 0.07 t")

test "at 7% a year the doubling time is 10.24 years" {
    assert_near(t_double, 10.2448, 1.0e-3)
}
test "after that long the amount is exactly 2" {
    assert_near(pow(1.0 + RATE, t_double), 2.0, 1.0e-12)
}
test "the rule of 70 is 2.4% off at 7% and 0.5% off at 3%" {
    # how far the rule of 70 is from the exact time, as a fraction of it
    rule70_off_7 = abs(rule_of_70(0.07) - doubling_time(0.07)) / doubling_time(0.07)
    rule70_off_3 = abs(rule_of_70(0.03) - doubling_time(0.03)) / doubling_time(0.03)
    assert_near(rule70_off_7, 0.024, 0.0005)
    assert_near(rule70_off_3, 0.005, 0.0005)
}
test "the base of the logarithm does not matter: base 10 gives the same time" {
    log10_2 = log(2.0) / log(10.0)
    log10_r = log(1.0 + RATE) / log(10.0)
    assert_near(log10_2 / log10_r, t_double, 1.0e-12)
}
test "compounded once a year, the n-times formula gives the yearly doubling time to 1e-12" {
    assert_near(doubling_time_n(RATE, 1.0), t_double, 1.0e-12)
}
test "compounded monthly at 7%, the money doubles in 9.931 years" {
    assert_near(t_monthly, 9.93096, 1.0e-4)
    assert_near(pow(1.0 + RATE / 12.0, 12.0 * t_monthly), 2.0, 1.0e-12)
}
test "more additions a year double it sooner, but never sooner than ln 2 / r" {
    assert_lt(doubling_time_n(RATE, 4.0), doubling_time_n(RATE, 1.0))
    assert_lt(doubling_time_n(RATE, 12.0), doubling_time_n(RATE, 4.0))
    assert_lt(doubling_time_n(RATE, 365.0), doubling_time_n(RATE, 12.0))
    assert_lt(t_continuous, doubling_time_n(RATE, 365.0))
}
test "ten thousand additions a year is ln 2 / r plus r/(2n) of it, the next term of the series" {
    excess = doubling_time_n(RATE, 1.0e4) / t_continuous - 1.0
    assert_near(excess, RATE / 2.0e4, 1.0e-9)
}

test "at a rate of one part in a trillion a year, the doubling time is ln 2 / r to one part in a billion" {
    assert_near(doubling_time(1.0e-12) * 1.0e-12 / log(2.0), 1.0, 1.0e-9)
}
test "at a rate of 1e-16 a year the doubling time is finite, 6.9e15 years" {
    assert_near(doubling_time(1.0e-16) * 1.0e-16 / log(2.0), 1.0, 1.0e-9)
    assert_near(doubling_time(1.0e-16), 6.9e15, 0.05e15)
}
test "money shrinking 5% a year never doubles: the doubling time is infinite" {
    assert_gt(doubling_time(-0.05), 1.0e300)
}
test "a billion additions a year double it in ln 2 / r, to one part in a billion" {
    assert_near(doubling_time_n(RATE, 1.0e9) / t_continuous, 1.0, 1.0e-9)
}

# what the reviewed program gives at the rates the tests try, for the notes:
# the decimal digits a 53-bit double carries, the part of 1 + 1e-12 kept
# after the 1, the relative error at a rate of 1e-12, and the "doubling time"
# at -5% a year
double_digits = 53.0 * log(2.0) / log(10.0)
stored_part = (1.0 + 1.0e-12) - 1.0
tiny_rate_error = abs(doubling_time(1.0e-12) * 1.0e-12 / log(2.0) - 1.0)
shrinking_time = doubling_time(-0.05)
show double_digits
show stored_part
show tiny_rate_error
show shrinking_time

# SPDX-License-Identifier: MIT OR Apache-2.0
# SPDX-FileCopyrightText: 2026 The Viv authors

RATE = 0.07

#| Years to double at a yearly rate, with interest added once a year.
def doubling_time(rate) {
    "How many years until the amount is twice what it started as."
    return log(2.0) / log(1.0 + rate)
}
#| The rule of 70: divide 70 by the rate written as a percentage.
def rule_of_70(rate) {
    return 70.0 / (100.0 * rate)
}
#| Years to double when the yearly rate is split into `times` smaller additions.
def doubling_time_n(rate, times) {
    "Each addition is rate/times; there are `times` of them a year."
    return log(2.0) / (times * log(1.0 + rate / times))
}

# the answers the notes quote
t_double = doubling_time(RATE)
show t_double
show rule_of_70(RATE)
t_monthly = doubling_time_n(RATE, 12.0)
show t_monthly
t_continuous = log(2.0) / RATE
show t_continuous

# the picture: growth that compounds, against growth that does not
# a point every quarter year for twenty years
N_TIMES = 81
ts = linspace(0.0, 20.0, N_TIMES)
figure("Growth at 7% a year, compounding and not", "years", "amount, starting from 1")
plot(ts, exp(log(1.0 + RATE) * ts), "$1.07^t$")
plot(ts, 1.0 + RATE * ts, "1 + 0.07 t")

test "at 7% a year the doubling time is 10.24 years" {
    assert_near(t_double, 10.2448, 1.0e-3)
}
test "after that long the amount is exactly 2" {
    assert_near(pow(1.0 + RATE, t_double), 2.0, 1.0e-12)
}
test "the rule of 70 is 2.4% off at 7% and 0.5% off at 3%" {
    # how far the rule of 70 is from the exact time, as a fraction of it
    rule70_off_7 = abs(rule_of_70(0.07) - doubling_time(0.07)) / doubling_time(0.07)
    rule70_off_3 = abs(rule_of_70(0.03) - doubling_time(0.03)) / doubling_time(0.03)
    assert_near(rule70_off_7, 0.024, 0.0005)
    assert_near(rule70_off_3, 0.005, 0.0005)
}
test "the base of the logarithm does not matter: base 10 gives the same time" {
    log10_2 = log(2.0) / log(10.0)
    log10_r = log(1.0 + RATE) / log(10.0)
    assert_near(log10_2 / log10_r, t_double, 1.0e-12)
}
test "compounded once a year, the n-times formula gives the yearly doubling time to 1e-12" {
    assert_near(doubling_time_n(RATE, 1.0), t_double, 1.0e-12)
}
test "compounded monthly at 7%, the money doubles in 9.931 years" {
    assert_near(t_monthly, 9.93096, 1.0e-4)
    assert_near(pow(1.0 + RATE / 12.0, 12.0 * t_monthly), 2.0, 1.0e-12)
}
test "more additions a year double it sooner, but never sooner than ln 2 / r" {
    assert_lt(doubling_time_n(RATE, 4.0), doubling_time_n(RATE, 1.0))
    assert_lt(doubling_time_n(RATE, 12.0), doubling_time_n(RATE, 4.0))
    assert_lt(doubling_time_n(RATE, 365.0), doubling_time_n(RATE, 12.0))
    assert_lt(t_continuous, doubling_time_n(RATE, 365.0))
}
test "ten thousand additions a year is ln 2 / r plus r/(2n) of it, the next term of the series" {
    excess = doubling_time_n(RATE, 1.0e4) / t_continuous - 1.0
    assert_near(excess, RATE / 2.0e4, 1.0e-9)
}

test "at a rate of one part in a trillion a year, the doubling time is ln 2 / r to one part in a billion" {
    assert_near(doubling_time(1.0e-12) * 1.0e-12 / log(2.0), 1.0, 1.0e-9)
}
test "at a rate of 1e-16 a year the doubling time is finite, 6.9e15 years" {
    assert_near(doubling_time(1.0e-16) * 1.0e-16 / log(2.0), 1.0, 1.0e-9)
    assert_near(doubling_time(1.0e-16), 6.9e15, 0.05e15)
}
test "money shrinking 5% a year never doubles: the doubling time is infinite" {
    assert_gt(doubling_time(-0.05), 1.0e300)
}
test "a billion additions a year double it in ln 2 / r, to one part in a billion" {
    assert_near(doubling_time_n(RATE, 1.0e9) / t_continuous, 1.0, 1.0e-9)
}

# what the reviewed program gives at the rates the tests try, for the notes:
# the decimal digits a 53-bit double carries, the part of 1 + 1e-12 kept
# after the 1, the relative error at a rate of 1e-12, and the "doubling time"
# at -5% a year
double_digits = 53.0 * log(2.0) / log(10.0)
stored_part = (1.0 + 1.0e-12) - 1.0
tiny_rate_error = abs(doubling_time(1.0e-12) * 1.0e-12 / log(2.0) - 1.0)
shrinking_time = doubling_time(-0.05)
show double_digits
show stored_part
show tiny_rate_error
show shrinking_time

# SPDX-License-Identifier: MIT OR Apache-2.0
# SPDX-FileCopyrightText: 2026 The Viv authors