Unit 3 activity: Meet the Bernoulli numbers

For learners after attempting the activity, and for instructors reviewing it. Working through this page before attempting Task 1 removes the only part of the module that has to happen before an AI system is involved.

Checkpoint answers are not restated here. Checkpoints are defined once in course/lab/checkpoints.py, and both self-check routes grade against that file. 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 on the student page, and with course/lab/reference_bernoulli.py.

Where the working usually goes wrong

Four slips account for nearly all incorrect answers, and each of them is worth recognising rather than merely correcting.

• Sign lost at the last step. The learner reaches 1/6 + 5·B4 = 0 and reads off 1/30 instead of -1/30. The sum equals zero, so the term containing B4 is the negative of everything else. This is the single most common error, which is worth saying aloud: the same slip, in code, produces a routine that disagrees with the reference at every even index.
• Stopping at n = 2. Answering 1/6 means the recurrence was run for B2 rather than B4. Usually 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 module later names not-fraction when it appears in generated code, and it is worth pointing out that it began here, on paper.

Why this task exists

The value matters less than its provenance. In Unit 4 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 behind labelled disclosures. This is an instructional boundary, not an access-control claim: a learner can still open the source or disclosure. The direction remains to attempt the derivation before doing so.

Task 2 — Diagnosing the disagreement

1. Where it disagrees. At exactly one index: B1. The file gives +1/2 where this module'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 not the signature of a bug. Bugs in a recurrence propagate: an error at B1 would corrupt B2, which would corrupt B4, and so on down the sequence. Here nothing propagates, which tells you the two programs are computing different things on purpose.

They are. The file uses the second Bernoulli convention, B1 = +1/2; this module uses the first, B1 = -1/2. Both are standard, both are published, and they differ in exactly this one value. The colleague's file is not broken. The specification that both of you were working to was incomplete.

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 the checker cannot tell those apart. You can, by looking at whether anything else moved.

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. Compare your sentence with the corresponding clause in Unit 6'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 module:

1. The general rule. Lovelace labels only the non-zero Bernoulli numbers. 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 renumbers the non-zero terms consecutively returns 1/6 for B1, -1/30 for B2, 1/42 for B3 — its bernoulli(k) is the modern B(2k). It skips the zeros as Note G does, though these are not Lovelace's labels either (hers run B1, B3, B5, B7 = modern B2, B4, B6, B8). Every value it returns is a genuine Bernoulli number, correctly computed, exactly represented. Every one is filed under the wrong index.

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 module names this failure mode ada-indexing, and you will meet a working example of it in Unit 5.

A note on the history: Note G's published table contains an error — established from a facsimile as an inverted division in operation 4 — while its attribution (who introduced it) remains contested. This unit does not depend on the error at all, and Unit 7 handles it properly. See course/historical-notes.md 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 worth drawing out in review:

• 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 a learner has written abs(a - b) < 1e-9, that tolerance will pass a float-based implementation for small indices and fail it at B30, 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 module's own checker treats this as its raises failure mode.

If a learner wants to go further, ask them to 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 numbering has no zeros in it anywhere.

Checkpoints

Attempt these from your own working:

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

python3 selfcheck.py run cp03-b4-by-hand    # or use the browser self-check

Both routes ask the same questions and give the same feedback. Answers and diagnostics live in course/lab/checkpoints.py.