Unit 6 activity: Meet the Bernoulli numbers

Read this after attempting the activity. Working through it before Task 1 removes the only part of the course that has to happen before an AI system is involved.

Checkpoint answers are not restated here. Each checkpoint is defined once, and the browser self-check and the terminal both read that one definition and grade against it. This page explains the reasoning; the checkpoints do the marking.

Task 1 — B4 by hand

The full working

With n = 4, the identity has five terms and every binomial coefficient is taken from row 5:

C(5,0)·B0 + C(5,1)·B1 + C(5,2)·B2 + C(5,3)·B3 + C(5,4)·B4 = 0

The coefficients are 1, 5, 10, 10, 5. Substituting B0 = 1, B1 = -1/2, B2 = 1/6 and B3 = 0:

(1)(1) + (5)(-1/2) + (10)(1/6) + (10)(0) + (5)(B4) = 0

Term by term:

1 - 5/2 + 5/3 + 0 + 5·B4 = 0

Putting the known part over a denominator of 6:

6/6 - 15/6 + 10/6 = 1/6

So:

1/6 + 5·B4 = 0
      5·B4 = -1/6
        B4 = -1/30

Which agrees with the table in the reading, and with course/lab/reference_bernoulli.py.

Where the working can go wrong

Four possible slips are worth recognising rather than merely correcting.

• Sign lost at the last step. You reach 1/6 + 5·B4 = 0 and read off 1/30 instead of -1/30. The sum equals zero, so the term containing B4 is the negative of everything else. This one is easy to make and worth saying aloud. Make the same slip in code and the routine is wrong at every index from B1 on. Its B1 is +1/2, which looks like the other convention. Its B2 gives it away: 5/6, not 1/6.
• Stopping before solving, or at n = 2. 1/6 is what the known terms add up to for n = 4 before you solve for B4; it is also B2, so it can mean the recurrence was run for B2 rather than B4. That points to a misread of which n to take, rather than an arithmetic error.
• Wrong binomial row. Using row 4 (1, 4, 6, 4, 1) instead of row 5. The identity uses n + 1 on top, not n, and it is easy to substitute n reflexively.
• Decimals. Converting to decimals partway through gives -0.0333…, which is not exact and cannot be compared for equality with -1/30. This is the same error that the course later names not-fraction when it appears in generated code, and notice that it began here, on paper.

Why this task exists

The value matters less than its provenance. In Unit 7 an AI system will produce a Bernoulli routine, and you will need a value that did not come from that system to judge it by. A number you derived is such a value. A number you looked up in the same conversation is not.

The course site withholds the numerical value in the initial reading and animations, then places the later tasks, this guidance, and the revealing mapping table in labelled sections you open yourself. This is a request, not a lock: you can still open the source or the section. The instruction is to attempt the derivation before you do.

Task 2 — Diagnosing the disagreement

1. Where it disagrees. At exactly one index: B1. The file gives +1/2 where this course's table gives -1/2. Every other value shown — B0, B2, B3, B4, B5, B6, B10, B12 — agrees exactly.

2. What that pattern means. A single-index disagreement, with everything around it untouched, is consistent with the second Bernoulli convention, B1 = +1/2; this course uses the first, B1 = -1/2. Both are standard, both are published, and they differ in exactly this one value. If that is what the file does, the colleague's file is not broken: the specification that both of you were working to was incomplete.

The output alone does not settle it. A sign error inside a recurrence would usually spread from B1 into later values, so the pattern rules that kind of bug out, but a sign error that touched only B1 would print exactly these values. To tell a convention from a bug, read the specification, the documentation or the code.

This is the failure mode the checker names b1-sign. It is worth noticing that the name describes what the output looks like, not a diagnosis of intent — the same output would result from a genuine sign error, and neither the checker nor you can tell those apart from the output alone.

3. The specification sentence. Any wording is acceptable provided it is testable and unambiguous. A reasonable version:

Use the first Bernoulli convention, in which B1 = -1/2.

The properties that make it a good requirement:

• It names the convention, so a reader can look it up.
• It states the value, so a reader who has never heard of the convention can still comply.
• It is checkable against a single output, which means a test can be written for it directly.

A version such as "use the correct Bernoulli numbers" fails all three: there is no such thing as the correct one here, and nothing can be tested against it. If your route includes Unit 10, compare your sentence with the corresponding clause in that unit's precise prompt. If yours is close, you have independently reinvented a piece of requirements engineering, which is what specification work mostly is.

Task 3 — Reading an index from Note G

The completed table, which is the locked mapping used throughout the course:

1. The general rule. Lovelace labels only the non-zero Bernoulli numbers, starting from the modern B2. The modern scheme spends an index on every term, including the odd ones that are zero, so her label numbers are one smaller: her Bk is the modern B(k+1), for odd k. Her B7 is the modern B8.

Two ways of getting this wrong are worth naming. Treating her labels as modern labels gives B7 = 0, since the modern B7 is an odd index above 1. Doubling — guessing that her B7 is the modern B14 — comes from noticing that only even indices are involved, but the rule is a shift by one, not a scaling. Writing out all four pairs makes the pattern visible immediately, which is why the task asks for the whole table rather than a single row.

2. Note G's B7. Note G's worked example computes Ada's B7, which is the modern B8. Its value is -1/30.

A modern routine that returned its own B7 would return 0, since every odd modern index above 1 is exactly zero — a plainly visible mismatch. The more dangerous version of this error is the one where nothing looks wrong at all: a routine that uses Lovelace's own labels returns 1/6 for B1, -1/30 for B3, 1/42 for B5 — her numbering runs B1, B3, B5, B7 for the modern B2, B4, B6, B8, and she has no B2 at all. Every value it returns is a genuine Bernoulli number, correctly computed, exactly represented. Every one is filed under Note G's index, not the modern one.

That combination — real values, wrong labels — is why reading the code carefully does not catch it. There is nothing in the code to catch. The mismatch only exists relative to a specification, and it only becomes visible when you compare against a reference index by index. The course names this failure mode ada-indexing, and you will meet a working example of it in Unit 8.

A note on the history: Note G's published table contains printed errors — the inverted division at operation 4 is established from a facsimile, and others in operations 24 and 21 rest on a self-published reconstruction — while their attribution (who introduced them) remains contested. This unit does not depend on the error at all, and Unit 16 handles it properly. See Historical Notes before repeating any account of it.

Task 4 — Optional CS extension

No single correct implementation. A reasonable one:

from fractions import Fraction

def first_divergence(claimed: dict[int, Fraction]) -> str:
    for n in sorted(TABLE):
        if n not in claimed:
            return f"B{n}: no value supplied"
        if claimed[n] != TABLE[n]:
            return f"B{n}: claimed {claimed[n]}, expected {TABLE[n]}"
    return f"no divergence up to B{max(TABLE)}"

Points to notice:

• Iterating in index order is what makes "first" meaningful. Iterating over the claimed dictionary in insertion order would report whichever divergence happened to be inserted first, which is not the same thing.
• Exact comparison. != between two Fraction objects is exact. If you wrote abs(a - b) < 1e-9, that tolerance passes the course's float-based example, float_output.py, at every index up to B23 and first fails it at B24, which is the worst possible behaviour: it hides the bug until the bug is expensive. Comparing a Fraction against a float in Python does work, and that is part of the hazard — it will silently succeed for Fraction(1, 4) and fail for Fraction(1, 6).
• A missing value is a finding, not a crash. A routine that has no answer at an index has failed the specification just as surely as one with a wrong answer. The course's own checker treats this as its raises failure mode.

To go further, add the property check that every odd index above 1 is exactly zero. That check needs no table at all — it tests a property rather than a value — and it catches the ada-indexing failure mode immediately, because a routine using Lovelace's labels puts its values on the odd indices: its B3 is her B3, the modern B4 = -1/30, where the property demands zero.

Checkpoints

Attempt these from your own working:

• cp06-b4-by-hand
• cp06-convention
• cp06-ada-index

python3 selfcheck.py run cp06-b4-by-hand  # or in the browser

Both routes ask the same questions and give the same feedback. Answers and diagnostics live in the checkpoint data below, which both routes read.