# Numerators of harmonic numbers

## Harmonic numbers

The nth harmonic number, Hn, is the sum of the reciprocals of the integers up to and including n. For example,

H4 = 1 + 1/2 + 1/3 + 1/4 = 25/12.

Here’s a curious fact about harmonic numbers, known as Wolstenholme’s theorem:

For a prime p > 3, the numerator of Hp-1 is divisible by p2.

The example above shows this for p = 5. In that case, the numerator is not just divisible by p2, it is p2, though this doesn’t hold in general. For example, H10 = 7381/2520. The numerator 7381 is divisible by 112 = 121, but it’s not equal to 121.

## Generalized harmonic numbers

The generalized harmonic numbers Hn,m are the sums of the reciprocals of the first n positive integers, each raised to the power m. Wolstenholme’s theorem also says something about these numbers too:

For a prime p > 3, the numerator of Hp-1,2 is divisible by p.

For example, H4,2 = 205/144, and the numerator is clearly divisible by 5.

## Computing with Python

You can play with harmonic numbers and generalized harmonic numbers in Python using SymPy. Start with the import statement

`from sympy.functions.combinatorial.numbers import harmonic`

Then you can get the nth harmonic number with `harmonic(n)` and generalized harmonic numbers with `harmonic(n, m)`.

To extract the numerators, you can use the method `as_numer_denom` to turn the fractions into (numerator, denominator) pairs. For example, you can create a list of the numerators of the first 10 harmonic numbers with

`[harmonic(n).as_numer_denom() for n in range(10)]`

You might notice that `harmonic(0)` returns 0, as it should. The sum defining the harmonic numbers is empty in this case, and empty sums are defined to be zero.

## 7 thoughts on “Numerators of harmonic numbers”

1. Very interesting!
Wrote a code snippet to test for primes using this property.

For fun I decided to create the harmonic function from what I just read, in Perl 6.

After maybe five minutes of testing and iterating on the REPL I came up with:

```sub harmonic ( UInt \$n, UInt \$m = 1 --> Rational ){
( [+] ({ 1 / ++\$ ** \$m } ... *)[^\$n] ).Rat
}```

( That includes the amount of time I spent playing with the code before trying to put it in a subroutine )

Since that is a bit dense, this is what it would look like if I expanded it out a bit, and added comments for someone new to Perl 6:

```sub harmonic ( UInt \$n, UInt \$m = 1 ) returns Rational {
# Generate an infinite list of reciprocals that are raised to the power of `\$m`.
# The `state` variable will maintain its value for each call of the block
# within this sequence. A new one is created for each new list.

my @reciprocals = { 1 / ++( state \$unnamed = 0 ) ** \$m } ... *;

# `1 / 2` returns a rational value
# (up to some arbitrarily huge denominator above uint64.Range.max )

# (^\$n)   eqv   (0 ..^ \$n)   eqv   Range.new( 0, \$n, :excludes-max )
# `^\$n` is typically called the `up to` operator
# `[ «OPERATOR» ] «LIST»` is the list reduction metaoperator
# which respects the left/right associativity of the infix operator

my \$sum = [+] @reciprocals[ ^\$n ];

# `[<=] 1, 2, 3, 4` it can be used to make sure a list is sorted
# note that `[+] ()` returns `0` because
# &infix:«+» with zero arguments returns `0`

# ensure that it returns a rational number
# only needed for the \$n == 0 case

return \$sum.Rat;
}```

If you want just the numerators for the first ten harmonic numbers
`my @n = (harmonic(\$_).numerator for ^10);`

If you want to format the output as a fraction:
`say harmonic(10).nude.join('/');`

3. Have you seen the chapter of Proofs That Really Count by Benjamin and Quinn that is all about combinatorial interpretations of harmonic numbers? I found it pretty amazing that such things could even exist at all! It’s a book I think you would enjoy, if you haven’t seen it, and it could give you a lot to add to this post.

4. The p^2 divisibility reminds me of Eisenstein’s irreducibility criterion. I wonder if there’s a connection.