Nina B. Zumel

Testing Comments on the Blog

2026-08-13T00:00:00Z

I've added a comment system! I know it's an odd thing to do, since this is a fairly inactive blog, but that's also what makes it a safe testing ground.

I've wanted a comment system ever since I switched to a static blog, but it's hard to find one that meets all my desiderata. It has to be hosted, but inexpensive--I don't want to figure out how to serve it myself, and I don't want to pay a lot of money when I basically expect zero comments. It has to be low friction and inclusive--I considered Utterances, which requires logging into Github to comment. That's probably okay for this blog, but people who read Dark Tales Sleuth won't necessarily have a Github account. And it has to look like an active project. Commentbox.io looked almost perfect, but I don't see any activity around it since 2018. Also, I have reservations about using Google or Facebook authentication.

So I'm testing out Remarkbox. It's pay-what-you-can and allows commenting without signing into anything. I know lack of verification is risky, but Remarkbox's email verification method was acting wonky. If it becomes a problem, I can turn off the comment auto-approval.

So feel free to try it, below. You don't need to log in to anything (unless you want to be notified about replies); just type in the comment box. Markdown will work.

If this works okay, I'll probably add comments to Dark Tales Sleuth, too.

Digital Difficulties

2025-03-14T00:00:00Z

This was originally posted to RWorks.

Here’s another puzzle, from Henry Dudeney’s Perplexities column in Strand Magazine, January 1924.

Arrange the ten digits, 1 2 3 4 5 6 7 8 9 0, in such order that they shall form a number that may be divided by every number from 2 to 18 without in any case a remainder. As an example, if I arrange them thus: 1 2 7 4 9 5 3 6 8 0, this number can be divided by 2,3,4,5, and so on up to 16, without any remainder, but it breaks down at 17.

One of the additional challenges in taking puzzles from these older sources is to try to solve them the way a puzzle-solver would have, back in 1924. In this case, I wasn’t successful at finding a pure paper-and-pencil solution, but I did find an elegant modern solution that would have been possible with the computational machines of the era.

But before I show you my solution, try it yourself, first! My solution after The Mathematicians.

The Mathematicians (1917)
Artist: Giorgio de Chirico. Source: WikiArt

Solution #

Let’s look at a super brute force solution first, and then a more elegant, but still not quite paper-and-pencil one.

The Brute Force Solution #

With a modern computer, one could simply generate all 10!= 3,628,800 possible permutations of the ten digits. Then, for each permutation, check whether it is divisible by all the integers from 2 to 18. This is brutal, but it works.

We can also reduce the number of permutations by taking advantage of some facts about divisibility.

A number is:

divisible by 10 (and 5) if the last digit is 0
divisible by 4 (and 2) if the last two digits are a number divisible by 4 (For an explanation of why, see here).

Combining these facts, we can deduce that the last two digits of our target number must be 20, 40, 60, or 80. This leaves (for each case), 8!= 40,320 permutations, giving us a total of 4* 40320 = 161,280 candidates to examine. That’s a much smaller number!

An Elegant Modern Solution #

Here’s a solution that reduces the number of candidates even more. This time, we’ll start by finding the smallest number, m, that is divisible by all the integers from 2 to 18. We know that our target number must be a multiple of m. Next, we find all the multiples of m in the appropriate range, and check which one(s) have ten unique digits. These will be the solutions.

Let’s code this solution up, in R.

Find the Least Common Multiple (LCM) of the integers from 2 to 18 #

We’ll start by multiplying all the primes in our range:

m = 2*3*5*7*11*13*17
m

[1] 510510

Note that this number is also divisible by 6=2*3, 10=2*5, 14=2*7, and 15=3*5. What factors are left? To save the trouble of tracking this by hand, we’ll write a function to return which integers in the range 2:18 a number m is not divisible by.

not_divisible_by = function(m) {
  candidates = 2:18
  
  remainders = m %% candidates
  candidates[remainders != 0]
}

not_divisible_by(m)

[1]  4  8  9 12 16 18

If we further multiply m by another 3, it will then be divisible by 9 and 18. If we then also multiply m by 4, it will be divisible by 4, 8, and 12. This leaves 16, which means we need another 2.

# 3 and 4, first
m = m*3*4
not_divisible_by(m)

[1] 16

# now an extra 2
m = m*2
not_divisible_by(m)

integer(0)

That gives us m = 12252240, which should be the smallest number divisible by all integers from 2 to 18. The number we want must therefore be a multiple of m.

Filter all the multiples of m #

Now we need to

find all the multiples of m in the appropriate range
find all the resulting numbers that have ten unique digits

First, we’ll find the range of candidates.

# the smallest possible candidate
minC = 1234567890

# the largest possible candidate
maxC = 9876543210

# the range of multipliers to consider
crange = round(c(minC, maxC)/m)
crange

[1] 101 806

This leaves 706 candidates to check, which is far fewer than 161,280. We already know all these candidates are divisible by all the integers from 2 to 18; we just need to check which ones are a number comprised of ten unique digits.

So let’s write the filter and do the calculation:

ten_unique_digits = function(nint) {
  nstring = as.character(nint)
  if(nchar(nstring) != 10) return(FALSE)
  
  # create a vector of digits
  digits = unlist(strsplit(nstring, split=""))
  
  length(unique(digits)) == length(digits)
}


candidates = m * crange[1]:crange[2]
cfilter = vapply(candidates, ten_unique_digits, logical(1))

solns = candidates[cfilter]
solns

[1] 2438195760 3785942160 4753869120 4876391520

There are 4 solutions! Let’s check manually that all solutions are valid.

for(s in solns) {
  print(paste("Checking solution", s))
  for(i in 2:18) {
    stopifnot(s %% i == 0)
  }
  print("--- Checks out")
}

[1] "Checking solution 2438195760"
[1] "--- Checks out"
[1] "Checking solution 3785942160"
[1] "--- Checks out"
[1] "Checking solution 4753869120"
[1] "--- Checks out"
[1] "Checking solution 4876391520"
[1] "--- Checks out"

# let's also find the multipliers
solns/m

[1] 199 309 388 398

And we are done! ✅

But How Would Dudeney Solve This? #

It’s easy to find m, the LCM of the integers from 2 to 18, with pencil and paper. But I have a hard time imagining that a puzzle-solver in 1924 would be willing to calculate candidate multiples of m by hand to find one with ten unique digits. Even if they started at 101m and worked their way up, they would have to check 199 - 101 + 1 = 99 candidates before they find a solution. That doesn’t sound fun anymore.

Fortunately, even in 1924, a sophisticated puzzle-solver (like Dudeney) might not need to do the calculation purely by pencil and paper. They could have used a mechanical calculator of the era, like the Arithmometer below:

The Odhner Arithmos, Type 5, circa 1912-1928. Source: Wikipedia

With such a device, a puzzle-solver could literally crank out multiples of m, scanning each one as they go, rejecting values with repeated digits, until they discover a solution to the puzzle. I imagine it could be done in under ten minutes—which would not be considered a long time for someone accustomed to more manual calculations.

You can read more about older calculation technologies in John Mount’s article, Calculating at Pencil and Paper Scale.

One of the descendants of the Arithmometer is the Curta calculator, and we at Win Vector just happen to have one! Solving this problem with a Curta would be much like solving it with an Arithmometer. Here’s a video of John Mount “finding” the smallest solution to the puzzle:

The discovered solution is in the black area, and the associated multiple of m is in the white area. Keep in mind that John already knew how many cranks he had to do before a solution came up, and after about the first two or three cranks, he stopped checking for duplicate digits. So this is probably a little faster than it would take someone who really didn’t know what the answer was.

Now that I know about the Arithmometer and related devices, I’m not too worried about whether Dudeney could have executed my solution. But I do feel sorry for any poor Strand Magazine readers who didn’t have the latest calculating technology. And I still wonder if I’m missing an even more clever trick, which would have made this solvable with just pencil and paper. If I ever find such a solution, I’ll post it here, and at Puzzle Corner on Rworks.dev. And if you ever find one, please do write in and let me know!

A Trick For Checking Divisibility by 11

2025-03-10T00:00:00Z

Continuing my theme from last time of mental calculation and divisibility tricks that I didn’t learn in school, here’s a cool one:

A number $N$ is divisible by 11 if the alternating sum of its digits is divisible by 11.

For example, take the number 2574. Its alternating sum is $2 - 5 + 7 - 4 = 0$ . Since 0 is divisible by 11, so is 2574.

Let’s check, in R.

M = 2574
# check divisibility directly
if(M %% 11 == 0) {
  result = paste(M, "is divisible by 11")
} else {
  result = paste(M, "is not divisible by 11")
}
result

## [1] "2574 is divisible by 11"

This can potentially be handy, if you ever want to know if a large number is divisible by eleven, and your pencil and paper are closer than your calculator app. Hey, it could happen!

We can prove the above fact, but first let’s review some facts about modular arithmetic. If you are comfortable with modular arithmetic, skip to the Proof section.

Preliminaries: Modular Arithmetic #

By definition, when we say a % b = c, we mean that a/b = kb + c for some value k—in other words, that c is the remainder of a/b. (Note that in R, %% is the operator for modular arithmetic).

When we say (a ~ b) % c (pronounced “a is congruent to b, modulo c”), we mean that (a-b) % c = 0. In other words, a and b are equivalent in the field defined by modulo c.

Modular Arithmetic with Negative Numbers #

The above is fairly intuitive with nonnegative numbers, but I always get confused when negative numbers appear. Let’s use the observation that

a/b = kb + (b-1) = (k+1) b + (-1)

In other words, (b-1) is the remainder of a/b with respect to some multiple of b (namely, kb), but -1 is the remainder of a/b with respect to the next multiple of b (namely, (k+1)*b).

This means that ((n-1) ~ -1) % n, and that all these statements are equivalent:

(n-1) % n = (n-1)
-1 % n = (n-1)
(n-1) % n = -1 % n

Specifically for our application: (10 ~ -1) % 11; and 10 % 11 = -1 % 11.

More Handy Facts #

These are ways that we can “push through” the modulo operator into certain expressions:

(a + b) % n = (a % n + b) % n
(ab) % n = ((a % n) * b) % n
(a^b) % n = ((a % n)^b) % n

With these tools in hand, we are ready to attempt the proof.

The Proof #

A number $N$ is divisible by 11 if the alternating sum of its digits is divisible by 11.

Let’s write $N$ as powers of 10:

N = \sum_{i = 0}^{n} 10^{i} a_{i}

Then (dropping the summation bounds, for neatness);

\begin{aligned} N % 11 & =[\sum_{i}10^{i}a_{i}]% 11 \\ =[\sum_{i}(10^{i}a_{i})% 11]% 11 \\ =[\sum_{i}a_{i}(10^{i}% 11)]% 11 \\ =[\sum_{i}a_{i}(10% 11)^{i}]% 11 \\ =[\sum_{i}a_{i}(-1% 11)^{i}]% 11 \end{aligned}

The last step follows because (10 ~ -1) % 11. Because we are working in “modulo 11” world, the last expression is also equivalent to

N % 11 = [\sum_{i} a_{i} (- 1)^{i}] % 11

The value -1 to an even power is 1; -1 to an odd power is -1. So the expression inside the brackets is the alternating sum of the digits of N.

Now we can see that if the alternating sum modulo 11 is zero, then N % 11 = 0. In other words, when the alternating sum is divisible by 11, so is $N$ . ✅

Testing it Out #

I confess, the proof gives me a headache. But we can test the procedure out on a random sample, to convince ourselves it works. First, let’s implement an alternating sum function.

# function that returns the absolute value of
# the alternating sum of a number's digits
alternating_sum = function(N) {
  nstring = as.character(N)
  
  # create a vector of digits
  digits = as.numeric(unlist(strsplit(nstring, split="")))
  nd = length(digits)

  # alternating +/-1; -1 to even powers is 1, to odd powers is -1
  signs = (-1)**(1:nd)
  abs(sum(digits * signs))
}

If you look carefully, you’ll see the alternating sum I’m calculating above is actually the negative of the one I did “by hand” at the beginning of this post: people will naturally start the sum with a positive coefficient for the first (leftmost) digit, but my code starts the sum with a negative coefficient, because R indexes from 1. But that doesn’t affect divisibility by 11, and in any case, I’m returning the absolute value of the alternating sum, for consistency.

Now let’s take a random sample of integers, and test.

set.seed(20250306)
# test a random sample of integers
mult11 = 0  # we'll count how many multiples of 11 that we saw

# generate 1000 unique integers from 1:999999
samples = sample.int(999999, size=1000)

for(sample in samples) {
  direct = (sample %% 11) == 0
  bysum = (alternating_sum(sample) %% 11) == 0
  
  if(direct) {mult11 = mult11 + 1}
  stopifnot(direct == bysum)
}

print(paste("Test successful; found", as.integer(mult11), "multiples of 11."))

## [1] "Test successful; found 94 multiples of 11."

So the alternating sum trick seems to work! As with the tricks in my previous post, this may not be the most useful tool in your arsenal, given that we all have calculators and computers. But it’s an interesting arithmetical fact, all the same. Who knows? Maybe you can turn it into a bar trick.

A Trick For Checking Divisibility by Powers of 2

2025-03-07T00:00:00Z

I’ve been working on another puzzle post, which will eventually show up here (but probably first on Rworks). Because the puzzles I present come from older sources---in this case, Strand Magazine from 1924---I try to solve the puzzles using techniques that a puzzle-solver would have access to at the time—in other words, techniques other than brute force search via computer.

While looking for such a solution to the current puzzle, I started thinking about various tricks for eyeballing the divisibility of integers. You probably remember these tricks from grade school: a number $N$ is divisible by 3 if the digits sum to something divisible by 3; divisible by 5 if the last digit is 5 or 0; divisible by 9 if the digits sum to something divisible by 9; and so on. I remember learning tricks for divisibility by 2, 3, 5, 9, and 10. And even though I have access to computers and calculators, I still sometimes use these tricks for quick mental calculations.

Here are a couple of tricks that I didn’t know, until I started looking into this topic:

$N$ is divisible by 4 if its last two digits are divisible by 4.
$N$ is divisible by 8 if its last three digits are divisible by 8.

These are both specific cases of the general rule

$N$ is divisible by $2^{k}$ if its last $k$ digits are divisible by $2^{k}$ .

So in this post, I’ll prove it, and provide a few examples of using the rule for mental or pencil-and-paper calculations, just for fun.

The Proof #

Let $N$ be the number we are checking. Say it has $D$ digits. Let $n$ be the value represented by the lowest $k$ digits of $N$ . Then the number $M = N - n$ is the value represented by the highest $D - k$ digits, followed by $k$ zeros.

As an example, if $k = 2$ then we write $N = 734$ as $734 = 700 + 34$ .

Any integer where the lowest $k$ digits are zero is divisible by $10^{k}$ . In our example, $M = 700$ is divisible by 100.

The next step is to establish that $10^{k}$ is always divisible by $2^{k}$ , which we can do in one line:

10^{k} = (2 * 5)^{k} = 2^{k} * 5^{k}

Now $10^{k}$ , and therefore $M$ , are always divisible by $2^{k}$ , and $N = M + n$ . So $N$ is divisible by $2^{k}$ iff $n$ is. ✅

Going back to our example, 734 is not divisible by 4, because 34 isn’t. But 732 is.

is_divisible_by = function(M, m) {
  if(M %% m == 0) {
    result = paste(M, "is divisible by", m)
  } else {
    result = paste(M, "is not divisible by", m)
  }
  result
}

is_divisible_by(734, 4)

## [1] "734 is not divisible by 4"

is_divisible_by(732, 4)

## [1] "732 is divisible by 4"

Notice that in proving the above, we also established that $10^{k}$ is always divisible by $5^{k}$ . So it is also true that

$N$ is divisible by $5^{k}$ if its last $k$ digits are divisible by $5^{k}$ .

So those are some divisibility tricks you may not have known. Let’s try applying them.

Fun with Mental Calculations #

All of the operations below should be doable in your head, or with the help of a pencil and the back of an envelope.

Is M = 9,937,654,480 divisible by 8? #

Since $8 = 2^{3}$ , all we need to do is check the last three digits, 480. Since $480 = 8 * 60$ is divisible by 8, 9,937,654,480 is, too.

# check
M = 9937654480
is_divisible_by(M, 8)

## [1] "9937654480 is divisible by 8"

Is M = 9,937,654,480 divisible by 16? #

$16 = 2^{4}$ , so now we need to check if 4480 is divisible by 16. This is certainly doable with pencil and paper. Let’s do it “in our head”.

We know 480 is divisible by 8, from above. We can break 4480 down into $4480 = 4000 + 480 = 8 (500) + 8 (60) = 8 * 560$ .

560 is divisible by 2. So 4480 is divisible by 2*8 = 16, which is what we want. Therefore, $M$ is divisible by 16.

is_divisible_by(M, 16)

## [1] "9937654480 is divisible by 16"

As an aside, 560 is also divisible by 4 (because 60 is divisible by 4), and by 8. So we also know that 4480 is divisible by 32 and by 64.

is_divisible_by(4480, 32)

## [1] "4480 is divisible by 32"

is_divisible_by(4480, 64)

## [1] "4480 is divisible by 64"

Is M = 9,937,654,480 divisible by 32? #

$32 = 2^{5}$ , so now we have to check 54,480. At this point it’s easier to do it with a calculator or computer, but let’s try it by hand anyway.

We know from above that 4480 is divisible by 32, so now we need to check if 50,000 is divisible by 32. We know it’s divisible by 8 (because 000 is divisible by 8), and if we have an envelope and a pencil handy we can calculate that $50000 / 8 = 6250$ .

Now, we can eyeball that 6250 is not divisible by 4 (because 50 is not divisible by 4). So 50,000 is not divisible by 32. Therefore $50, 000 + 4480 = 54, 480$ is not divisible by 32, and neither is $M$ .

is_divisible_by(54480, 32)

## [1] "54480 is not divisible by 32"

is_divisible_by(M, 32)

## [1] "9937654480 is not divisible by 32"

Fun, but is it Practical? #

In an era of calculators and computers, the math fact we just proved has limited value, since it’s just as easy to divide the full number by $2^{k}$ as it is to divide the lowest $k$ digits. But the trick might still be handy, if you ever want to quickly check if something is divisible by 4 or 8, without reaching for the calculator app on your phone.

And it’s fun to exercise your brain with mental arithmetic or pencil and paper calculations, once in a while.

Dyson’s Algorithm for the Twelve Coins Problem

2024-10-23T00:00:00Z

After having worked on The Twelve Coins Puzzle by hand, I got curious about implementing Dyson’s “elegant” oblivious solution, which I mentioned in that previous post. While a quick skim gave me the general gist of the approach—and it is elegant—a deeper read for details made me wonder how mathematicians ever got anything done at all, in the old days. The note is telegraphic, to say the least.

But I finally figured it out, and coded it up in R. This may actually be the preferable language, since Dyson’s discussion indexes from 1, as R does. The basic idea is to label each coin by its trinary representation, and then to schedule the weighings in such a way that, with the appropriate representation of the measurement outcomes, the weighings “spell out” the label of the dud coin, if it exists. There is a known label for the case when there is no dud.

Dyson’s original algorithm used standard base-3 representations, where the digits are (0, 1, 2). I decided to implement my version using signed trinary, where the digits are (-1, 0, 1). This is the representation that I used for the Four Weights Puzzle, and I just find it more natural for balance scale problems. As a bonus, it also makes Dyson’s algorithm easier to describe.

The algorithm below works specifically for the case where the number of coins is exactly

M = (3^{n_{r o u n d s}} - 3) / 2

and $n_{r o u n d s}$ is the number of weighings. This is the maximum number of coins that can be resolved in $n_{r o u n d s}$ weighings: 3 coins in 2 weighings, 12 coins in 3 weighings, 39 coins in 4, etc. Not only is this exactly the situation we care about, it also keeps the algorithm consise. Dyson does discuss how to tweak the procedure for the case when $n_{c o i n s} < M$ (as long as it’s greater than 3). That procedure isn’t quite as pretty, and obscures the main virtues of the idea. I’ll defer discussion of it until later.

The Algorithm #

I’ll describe the procedure with the example $M = 3, n = 2$ (3 coins, 2 weighings), since that’s easy to work out by hand. Then I’ll point you to some code for larger cases.

1: Label the coins with the numbers 1 through $M$ , and convert them to signed trinary using $n$ digits. I’ve described the conversion procedure to signed trinary before, here. For $M = 3, n = 2$ , that looks like this:

1 = [0 1]
2 = [1 -1]
3 = [1 0]

2: Set the trinary representations to rotate “forward.”

We say that a number in base-3 rotates “forward” (Dyson called it “clockwise”) if the first change of digits increases by 1, modulo 3. So the forward sequence is $- 1 \to 0 \to 1 \to - 1 . . .$ (Note that $(- 1) - 1 = - 2$ , and $- 2 \mod 3 = 1$ ). In R, that looks something like this, assuming you’ve implemented the base-3 number as a vector:

is_forward = function (ptrinary) {
  delta = diff(ptrinary)
  # get only the nonzero diffs
  delta = delta[!(delta==0)]

  if(length(delta)==0)
    stop("constant vector")

  # check if we are rotating forward, and return
  delta[1] %% 3 == 1
}

If a signed trinary number $x$ rotates forward, then its negation $- x$ rotates backward, and vice-versa. So replace any of the coin labels that rotate backwards with its negation:

1 = [0 1] : rotates forward
2 = [1 -1]: rotates forward
3 = [1 0]: rotates backward, so replace with [-1 0] (-3)

Representing all the coins with forward rotating numbers removes the ambiguity that arises from not knowing whether the dud coin is heavier or lighter than the good coins: if the balance scale tilts the left pan down, that could be because a heavy dud is in the left pan, or because a lighter dud is in the right pan. As we will see, setting all the coin labels to rotate forward means that a heavy dud will produce a pattern of behaviors that “spell out” the location of the dud, while a light dud will spell out the negation of the label.

3: Plan the weighing schedule.

Now let’s label the possible positions on (or off) the scale. $- 1$ means the left pan, $1$ means the right pan, and $0$ means the table. The weighing schedule is such that for the $i$ th weighing, a given coin is in the location described by its label’s $i$ th digit (counting from the left, so the ones digit is last). For our example, this gives the schedule:

1 = [0 1]: table, then right pan
2 = [1 -1]: right pan, then left pan
3 = [-1 0]: left pan, then table

Using the scale notation we’ve been using for balance scale problems, that looks like this:

First weighing:

[coin 3 | coin 2]
------------------
coin 1

Second weighing:

[coin 2 | coin 1]
-----------------
coin 3

Note that the weighing schedule can be calculated in advance if you know $M$ (and $n$ ), before you even see a specific set of coins. It can also be used over and over, for any set of $M$ coins. This is what we mean when we call this algorithm “oblivious.”

4: Weigh the coins according to the schedule

We’ll record the outcome of each weighing, $a_{i}$ , as which pan was heavier (if any): $- 1$ means the left pan is heavier, $1$ means the right pan is heavier, $0$ means the scale is balanced. This means that if the $k$ th coin is a heavy dud, it will spell out its own label in signed trinary, as $[a_{1} a_{2} . . . a_{n}]$ . A light dud will spell out the negation of its label. You can recover the decimal representation of the total outcome, as

A = \sum_{i = 1}^{n} 3^{n - i} a_{i}

Then the location of the dud is $| A |$ , and the dud is heavy if $[a_{1} a_{2} . . . a_{n}]$ rotates forward, and it is light if $[a_{1} a_{2} . . . a_{n}]$ rotates backward. If there is no dud, then $A = 0$ .

Note that the sign of $A$ is NOT whether the dud is heavy or light; it’s whether the trinary representation of $| A |$ rotates forward or backward.

And that’s it! Let’s walk through a few examples.

No dud
- Scale: (balanced, balanced), so $a = [0, 0] \to A = 0$ : no dud
The dud is coin 1, and it is light
- Scale: (balanced, left), so $a = [0, - 1] \to A = - 1$ and $a$ rotates backward: coin 1, light.
The dud is coin 2, and it is heavy
- Scale: (right, left), so $a = [1, - 1] \to A = 2$ and $a$ rotates forward: coin 2, heavy.
The dud is coin 3, and it is heavy
- Scale: (left, balanced), so $a = [- 1, 0] \to A = - 3$ and $a$ rotates forward: coin 3, heavy.

Back to the 12 coins #

So now we can do the problem that we actually care about. I have R code to implement it, here.

Let’s show the forward representations of the coins.

# https://github.com/NinaZumel/DysonsAlgorithm/blob/main/dyson_signed_specialcase.R
source("dyson_signed_specialcase.R")

nrounds = 3
ncoins = (3^nrounds - 3)/2  # 12

# Show the forward representations of the coins
get_forward_representation(nrounds)

##       [,1] [,2] [,3]
##  [1,]    0    0    1
##  [2,]    0    1   -1
##  [3,]    0    1    0
##  [4,]    0    1    1
##  [5,]    1   -1   -1
##  [6,]    1   -1    0
##  [7,]    1   -1    1
##  [8,]   -1    0    1
##  [9,]   -1    0    0
## [10,]   -1    0   -1
## [11,]    1    1   -1
## [12,]   -1   -1    0

In my implementation, I precompile the weighing schedule ahead of time, so I can just weigh coins over and over again. The precompile() function calls get_forward_representation() internally, and returns a list. Each element of the list is the weighing schedule for that weighing, as a data frame, with columns (left, table, right). Each column of the data frame holds the coins that go into that position for that weighing.

Cset = precompile(ncoins, nrounds)

# show the schedule 
knitr::kable(Cset[[1]], caption = "Weighing 1")

left	table	right
8	1	5
9	2	6
10	3	7
12	4	11

Weighing 1

knitr::kable(Cset[[2]], caption = "Weighing 2")

left	table	right
5	1	2
6	8	3
7	9	4
12	10	11

Weighing 2

knitr::kable(Cset[[3]], caption = "Weighing 3")

left	table	right
2	3	1
5	6	4
10	9	7
11	12	8

Weighing 3

Now we can find duds. It doesn’t matter how much the coins weigh, as long as all good coins weigh the same amount. My function find_dud() returns a value D such that abs(D) gives the index of the dud, and sign(D) gives the dud’s relative weight; negative means the dud is light, and positive means the dud is heavy. In other words, $D \neq A$ !! But the notation is concise, and easy to write checks for.

# a good coin weighs 1 unit
coins = numeric(ncoins) + 1
epsilon = 0.5

# check the no dud case
find_dud(coins, Cset)

## [1] "No dud."

## [1] 0

# check a specific case
idud = 7
relative_wt = -1 # make it lighter
coins[idud] = 1 + epsilon*relative_wt
find_dud(coins, Cset)

## [1] -7

# verify this works in all possible cases
for(idud in 1:ncoins) {
  for(relative_wt in c(-1, 1)) {
    actual = idud*relative_wt # location and direction
    coins = numeric(ncoins) + 1
    coins[idud] = 1 + epsilon*relative_wt
    A = find_dud(coins, Cset)
    stopifnot(actual==A)
  }
}

And that’s the solution of the $M$ coins in $n$ weighings problem, for the special case when $M = (3^{n} - 3) / 2$ . I also have an implementation (and description) of the general situation, when $3 \leq M \leq (1 / 2) (3^{n} - 3)$ . If you are curious, that description is here, and it points to the implementation.

Reference #

Dyson, Freeman J. “Note 1931–The problem of the pennies,” The Mathematical Gazette Vol. 30, No 291) (October 1946). JSTOR link

The Twelve Coins Puzzle

2024-10-17T00:00:00Z

Photo by Marco Verch, CC-2.0. Source

This is a notoriously hard problem that comes in many flavors. I don't know where it comes from originally, but it garnered quite a bit of attention from mathematicians in the mid-twentieth century. Apparently some versions of it may have even distracted scientists away from their defense research during WWII !

The problem was popular on both sides of the Atlantic during World War II; it was even suggested that it should be dropped over Germany in an attempt to sabotage their war effort... (Guy & Nowakowski 1995)⊕ Guy, Richard, and Richard Nowakowski. "Coin-Weighing Problems," The American Mathematical Monthly Vol. 102, No. 2 (Feb. 1995). JSTOR link

Here's the version I set out to solve:

You have twelve coins, to appearance exactly identical; but possibly one is counterfeit (we'll call it a "dud"). You do not know if a dud is present, nor whether it is heavier or lighter than the good coins. Can you determine in three weighings on a balance scale: (1) whether there is a dud, (2) if so, which coin, and (3) its relative weight (lighter or heavier than the good coins)?

An additional detail:

You can assume that the coins are distinguishable in a balance pan (or on the table).⊕ This doesn't contradict the "exactly identical" condition in the problem statement, because you can group them in the pan or on the table spatially to distinguish them. This means that if you have grouped the coins into, say, two groups, $A$ and $B$ , and you put some coins from each group into a single pan, you know which of those coins are from $A$ and which are from $B$ .

You can also find this puzzle (or some version of it) online as "The Twelve Balls problem." I made a point of not looking at any online solutions, but I did skim the Guy and Nowakowski paper cited above---it does not have a solution, just some history and other details.⊕ Mostly, I used the observation that the coins are distinguishable in a balance pan. Without that allowance, I don't think the problem is solvable for twelve coins.

John Mount skimmed the format of other solutions (he swears he didn't read any of them); they tend to be structured as a long and tedious case tree. So in addition to finding a solution, he and I also came up with a somewhat more consise notation and presentation for the solution. It does shorten the description of the identification procedure somewhat. Hopefully, it also makes it easier to read.

Our solution is after the three-cent nickel.

Source: Wikimedia

Our Solution #

To make the ultimate identification procedure (hopefully) easier to follow, we'll present our notation, and some useful transformation rules and lemmas before we get to the solution procedure.

Notation #

We will annotate the coins as follows:

$?$ : coin of unknown state
$G$ : the coin is known to be a good coin
$L$ : the coin is possibly a dud, and if so, is lighter than a good coin
$H$ : the coin is possibly a dud, and if so, is heavier than a good coin

We'll count how many coins of a type we have with a superscript; so for example, $?^{12}$ means that we have 12 coins of unknown state (this is our starting position). When there's only one coin, we'll drop the superscript.

The goal is to end up in the state $X G^{11}$ , where $X \in {H, L, G}$ , the last value marking the situation where there is no dud.

We'll annotate a weighing as

[ Set_left  | Set_right ]
--------------------------
Table

where Set_left are the coins in the left pan, Set_right in the right pan, and Table what remains on the table.

Some transformation rules #

Transformation 1. $G$ is a terminal state #

Once you know a coin is good, it can never go bad.

Transformation 2. $H$ and $L$ can only go to $G$ , not to the opposite weight #

If a coin has been on the heavy side of the scale, then it must either be neutral (a good coin) or heavy. It cannot ever become light. Similarly for coins that have been on the light side of the scale.

As a corollary, if a coin marked $H$ does end up on the light side of the scale in a subsequent weighing, then it must be $G$ . A similar argument applies to $L$ coins.

Transformation 3. Transformation on a balanced weighing #

[ X^L | X^R ]
--------------  
X^T

--balanced--> X^L, X^R -> G^{L+R}, table states unchanged

In other words, if the scale is balanced, everything on the scale is good, and the dud must be on the table.

Transformation 4. Transformation on an unbalanced weighing #

[ X^L | X^R ]
--------------  
X^T

--unbalanced--> X^{T} -> G^{T}, states on scale change depending 
on coin location and previous state.

In other words, if the scale is unbalanced, then the dud must be on the scale, and everything on the table must be good. Everything on the heavy side of the scale is either $H$ or $G$ (see transformations 1 and 2); everything on the light side of the scale is either $L$ or $G$ . (ditto).

Some Useful Lemmas #

Lemma 1. $L^{2} H$ and $H^{2} L$ can be resolved in one weighing if a dud is known to be present. #

I'll do the $L^{2} H$ case; the other one follows from a similar argument. To make the argument simple, we'll assume these are the only three coins in the world (any remaining coins are already $G$ ).

Weigh as

[L | L]
---------
H

If the scale is balanced, then by transformation 3 this goes to $G^{2} H$ and we are done.

If the scale is unbalanced, then by transformation 4 the table becomes $G$ , and by transformation 2 the coin on the heavy side becomes $G$ , and we end up with $G^{2} L$ and we are done. ✅

Lemma 2. $H L G$ can be resolved in one weighing if a dud in known to be present. #

To make the argument simple, we'll again assume these are the only three coins in the world (any remaining coins are already G).

Weigh as

[H | G]
-------
L

(or vice versa). If the scale balances, then $L$ is the dud, and is light; otherwise $H$ must be the dud (and is heavy). ✅

Lemma 3. $? G$ can be resolved in one weighing. #

This is fairly obvious, but I'll state it. Again, we'll assume these are the only two coins in the world (any remaining coins are also already G). Weigh as:

[? | G]
-------

If the scale is balanced, the last coin is $G$ (there is no dud). If it's unbalanced, then if $?$ is on the heavy side, it's $H$ , otherwise it's $L$ . ✅

The Solution Procedure #

Let's assume for the moment that there is a dud. We'll do the "possibly no dud" case afterwards.

The initial state is $?^{12}$ . For the first weighing, divide the coins into three groups of four:

w1 = [?^4 | ?^4]
     -----------
        ?^4

There are two outcomes:

The scale is balanced, which gives us $G^{8}, ?^{4}$ (the dud is on the table).
The scale is not balanced, which gives us $L^{4}, H^{4}, G^{4}$ (the dud is on the scale).

If the scale is balanced on the first weighing #

Then we are in the state $G^{8}, ?^{4}$ . Our second weighing is

w2 = [?^2 | ? G]
    -------------
       ? G^7

(put three of the remaining unknowns back on the scale, with one good coin).

If the scale is balanced, then everything on the scales is $G$ , and we have $G^{4}, ?, G^{7} \to (G^{11}, ?)$ . By Lemma 3, we can resolve this in one weighing for three total, and we are done. ✅
If the scale is not balanced then everything on the table is $G$ , and we have either
- $L^{2} H G^{9}$ if the left side is lighter, or
- $H^{2} L G^{9}$ if the right side is lighter.
Either way, by Lemma 1 we can resolve this in one weighing for three total, and we are done. ✅

If the scale is not balanced on the first weighing #

Then we are in the state $L^{4}, H^{4}, G^{4}$ . Make the second weighing

w2 = [L^2 H | L H G]
     ----------------
        L H^2 G^3

This is not obvious, and I confess we found it by trial and error. The key insights that lead to this are that (1) you can't resolve more than 3 coins in one weighing (so you can't have more than three unresolved coins on either side of the scale, or on the table); and (2) symmetric weighings don't give you enough information.

If the scale is balanced, then everything on the scales is $G$ , and on the table you have $H^{2} L G^{3}$ . By Lemma 1 we can resolve this in one weighing for three total, and we are done. ✅
If the scale is not balanced then everything on the table is $G$ , and on the scale we have either
- $L^{2} G | G^{2} H \to L^{2} H G^{3}$ (by transformation 2) if the left side is lighter, or
- $G^{2} H | G^{2} L \to L H G^{4}$ (by transformation 2) if the right side is lighter.
In the first case, Lemma 1 resolves it in one weighing; in the second case, Lemma 2 resolves it in one weighing. That's three total, and we are done. ✅

This resolves all cases when a dud is known to be present. But what about the case when a dud is not known to be present? If there is no dud, then the scale will always balance, and if you trace back through the above, you'll see there is only one path:

$(?^{12}) \to (G^{8}, ?^{4}) \to (G^{11}, ?)$

and by Lemma 3, that last state can be resolved in one weighing, whether or not there is a dud.

This resolves all cases, including the "no dud" case. We can identify the dud if it exists, and determine its relative weight. And we are done. ✅✅

Some Further Discussion #

After we finished our solution, we dug into some others. As referenced by Guy and Nowakowski, Freeman J. Dyson gave an "elegant" solution to the general problem (resolve $N$ coins in $n$ weighings) in 1946.⊕ Dyson, Freeman J. "Note 1931--The problem of the pennies," The Mathematical Gazette Vol. 30, No 291) (October 1946). JSTOR linkIt is an oblivious solution, meaning Dyson predefines a sequence of weighings, which at the end is guaranteed to identify the dud (if there is one) and its weight, or report that there is no dud. This contrasts with our---and I suspect, most---solutions, that determine the next weighing after seeing the results of the previous one. I imagine it is far more automatable than a solution like ours. In broad strokes, it seems to be an approach in the spirit of the Four Weights Puzzle: it involves labeling the coins with a trinary representation.

Dyson (and others) also show that twelve coins is the most that you can resolve in three weighings, under the conditions I gave in the problem statement. I suspect (though I don't see a proof for it, and I'm too lazy to prove it myself) that if we relax the problem to assume that there is a dud, and try to identify it, but not necessarily its weight, we can resolve up to thirteen coins in three weighings.⊕ Dyson does show that if you have one extra coin that is known to be good, you can resolve 13 unknown coins in three weighings (and determine the weight of a dud).

If you remove the accomodation that coins are distinguishable in the balance pan (meaning that once you dump a bunch of coins in the pan, you can't tell where any individual coin came from), the maximum number of coins you can resolve in three weighings appears to be ten (from a formula given by Guy and Nowakowski).

Finding x: or, Back To the Four Weights Problem

2024-10-14T00:00:00Z

I was thinking about the Four Weights problem again recently. You might recall that puzzle poses the question: what are the four weights that can weigh any object $x$ in the (integer) range 1 to 40 on a balance scale?

A balance scale and four weights. Image Source

The puzzle just asks you to find the values of the weights, which are $(1, 3, 9, 27)$ . But how do you weigh $x$ —that is, with (an unknown) $x$ in the right-hand pan of the scale, how do you determine the distribution of weights so that the scale balances?

I’m sure if I were the merchant who had to do this every day, I’d quickly get an approximate feel for the weight of any $x$ I handled, and could balance the scale quickly and instinctively. But to write down the procedure in the abstract—it’s probably essentially something like binary search—isn’t pretty. And what’s the point of recreational math, if it isn’t pretty?

So I reduced to a simpler problem: If I know the value of $x$ , how do I balance the scale?

This isn’t a practical question, since if I know $x$ , then I don’t have to weigh the object. But it is kinda pretty. It also brings up a cute little observation about modular arithmetic, and so it felt worth a short writeup. The solution is based on a standard procedure for converting decimal values to a base- $n$ representation. If you are familiar with that procedure, you can skim the next section and/or skip to here. Otherwise, read on.

Converting $x$ to a base-n representation #

Assume you want to represent a nonnegative integer with up to $m$ digits in binary. Recall that $m$ binary digits can represent any number in the range $0 : (2^{m} - 1)$ . This is the pseudo-code.

i = 0        # assume indexing starts at 0
r = zeros(m) # all-zeros vector of length m
if x >= 2^m then throw("x is out of range")

while x > 0
  d = floor(x/2)
  r[i] = x mod 2
  x = d
  i = i+1
  
return reverse(r)  # so lowest value digit is rightmost

Let’s do it by hand for $x = 13$ , using 4 digits (which can represent up to the value $2^{4} - 1 = 15$ ).

13/2 = 6 rem 1 (d = 6, r = 1)
6/2 = 3 rem 0
3/2 = 1 rem 1
1/2 = 0 rem 1

So we have 13 = 1101 in base-2, or (1*8) + (1*4) + (0*2) + (1*1).

For an unsigned trinary representation, the idea is the same, only you divide by 3 instead of 2. Let’s try it with 18, using 4 digits (which can represent up to the value $3^{4} - 1 = 80$ ).

18/3 = 6 rem 0
6/3 = 2 rem 0
2/3 = 0 rem 2

So 18 = 0200 in base-3, or (0*27) + (2*9) + (0*3) + (0*1).

We can write a general function to convert a decimal number x to base-n representation. I’ll do it in R, just because I’ve been doing all my puzzles in R.

# convert x to its unsigned base-n representation
# n: the base
# ndigits: the maximum number of digits
base_n = function(x, n, ndigits) {
  r = numeric(ndigits)
  if(x >= n^ndigits) stop("x is out of range")
  i = 1
  while(x > 0) {
    d = floor(x/n)
    r[i] = x %% n
    x = d
    i = i+1
  }
  
  rev(r)
}

# convert from unsigned base-n back to decimal
to_decimal = function(r, n) {
  r = rev(r) # put the lowest digit to the leftmost
  ndigits = length(r) 
  x = 0
  for(i in 1:ndigits)
    x = x + r[i] * n^(i-1)
    
  x
}

# convert 13 to binary
r = base_n(13, 2, 4)
# confirm this is 13
stopifnot(to_decimal(r, 2)==13)
r

## [1] 1 1 0 1

# convert 18 to trinary
r = base_n(18, 3, 4)
# confirm this is 18
stopifnot(to_decimal(r, 3)==18)
r

## [1] 0 2 0 0

Converting $x$ to signed trinary #

Recall that when solving the Four Weights problem, we established that any nonnegative integer value $x$ in the range 1:40 could be represented as

s_{1} w_{1} + s_{2} w_{2} + s_{3} w_{3} + s_{4} w_{4} = x .

where the weights $w_{i}$ are (1, 3, 9, 27)—we write it smallest-first, consistently with the previous post on this problem—and $s_{i} \in {- 1, 0, 1}$ , rather than the ${0, 1, 2}$ of unsigned trinary. A positive coefficient means the weight goes in the left pan, a negative coefficient means the weight goes in the right pan with $x$ , and 0 means the weight isn’t used.

The four digits still represent $3^{4} = 81$ unique values, but some of them are now negative. For the Four Weights problem, we are only concerned with nonnegative $x$ , of which we can represent 0, plus $(3^{4} - 1) / 2 = 40$ values—the numbers 1:40. So we’ll concentrate on just expressing these nonnegative integers.

To modify the unsigned trinary conversion to a signed one, we use the observation that

The equation x/3 = d rem 2 is equivalent to the equation x/3 = (d+1) rem -1.

This is a bit of an abuse of the notation; but here’s an example of what we are trying to say. We know that

8/3 = 2 rem 2, which is the same as saying 8 = 2*3 + 2.

Another way of writing this is

8 = (2+1)*3 - 1 = 3*3 - 1 which we’ll write as: 8/3 = 3 rem -1

So (when considering only nonnegative $x$ ) the pseudo-code for the algorithm becomes:

i = 0  # assume indexing starts at 0
r = zeros(m)
maxval = (3^m - 1)/2
if x > maxval then throw("x is out of range")

while x > 0
  d = floor(x/3)
  r[i] = x mod 3
  if r[i]==2
    d = d+1
    r[i] = -1
  x = d
  i = i+1
  
return r  # we won't reverse it, to be consistent with our puzzle solution

Let’s convert 18 to signed trinary.

18/3 = 6 rem 0
6/3 = 2 rem 0
2/3 = 0 rem 2 = 1 rem -1
1/3 = 0 rem 1

So 18 = [0 0 -1 1] = (0*1) + (0*3) + (-1*9) + (1*27). In the scale notation that we used while solving the puzzle, we would write this as $[{27} | {x, 9}]$ , meaning the 27-weight is in the left pan, and the 9-weight is in the right pan with $x$ .

Here’s the code.

# convert nonnegative x to signed trinary
weigh = function(x) {
  if(x > 40) stop("x out of range")
  r = numeric(4)
  i = 1
  while(x > 0) {
    d = floor(x/3)
    r[i] = x %% 3
    if(r[i]==2) {
      d = d+1
      r[i] = -1
    }
    x = d
    i = i+1
  }
  r
}

# write the signed trinary representation in our scale notation
scale_notation = function(signs) {
  w = c(1, 3, 9, 27)
  lefti = which(signs > 0)
  righti = which(signs < 0)
  
  leftset = paste(w[lefti], collapse=", ")
  if(length(righti) > 0)
    rightset = paste("x,", paste(w[righti], collapse=", "))
  else
    rightset = "x"
  
  notation = paste("[ {", leftset, "} | {", rightset, "} ]")
  notation
}

# convert signed trinary back to decimal
to_x = function(signs) {
   w = c(1, 3, 9, 27)
   x = sum(w*signs) # dot product of w and signs
}

Let’s try a few.

x = 18
signs = weigh(x)
# convert back and check it's the same number
stopifnot(x == to_x(signs))
scale_notation(signs)

## [1] "[ { 27 } | { x, 9 } ]"

x = 35
signs = weigh(x)
stopifnot(x == to_x(signs))
scale_notation(signs)

## [1] "[ { 9, 27 } | { x, 1 } ]"

x = 15
signs = weigh(x)
stopifnot(x == to_x(signs))
scale_notation(signs)

## [1] "[ { 27 } | { x, 3, 9 } ]"

x = 30
signs = weigh(x)
stopifnot(x == to_x(signs))
scale_notation(signs)

## [1] "[ { 3, 27 } | { x } ]"

x = 4
signs = weigh(x)
stopifnot(x == to_x(signs))
scale_notation(signs)

## [1] "[ { 1, 3 } | { x } ]"

So now we can weigh objects we know the weight of. Hurrah? But I still think it’s cute.

The Wine Thief Problem

2024-10-10T00:00:00Z

This puzzle is again from Dudeney's "The Worlds Best Puzzles", in the December 1908 Strand Magazine. It's another one from Bachet, who gave us The Four Weights Problem.

A wine connoisseur has a wine-bin of eight compartments, containing 60 bottles of wine, as shown below:

His dishonest employee steals 4 bottles and rearranges the remainder. The connoisseur notices that the bottles have been rearranged, but on counting, he notes that there are still 21 bottles on each side, so he decides that everything is fine.

The employee, emboldened, steals 4 more---and then another 4, and then another 4, for a total of 16 bottles. Each time, he rearranges the remaining bottles so that there are 21 bottles on each side.

How did the employee arrange the bottles after each theft, so that the connoisseur never noticed?

Yes, the connoisseur was amazingly unobservant, or amazingly naive, but let's just roll with it. Solution after Chirico's The Mathematicians.

The Mathematicians (1917)
Artist: Giorgio de Chirico. Source: WikiArt

Solution #

A little thought should convince you that there is a symmetric solution: the thief steals a bottle from each center bin and then moves another bottle from the center into a corner bin appropriately. So the wine bins always look like this:

for some values of $a$ and $b$ . Let's set that up algebraically.

$2 a + b = 21$ (the sum of each side is 21)
$4 a + 4 b = w$ , where $w$ is the number of wine bottles remaining.

Look familiar? Since $a$ and $b$ , and $w$ are all nonnegative integers, and so are the coefficients, this is another system of Diophantine equations, similar to 100 Bushels of Corn.

We know what the $w$ are from the problem statement: [60, 56, 52, 48, 44].Define $n = w / 4$ to make things easier (note $n$ is also a nonnegative integer). Then a bit of algebra gives you:

\begin{aligned} a & =21-n \\ b & =2n-21 \\ w & =4n \\ n & \in15:11 \end{aligned}

(I'm counting $n$ backwards because that's the progression of the puzzle).

Notice that this follows the general form of Diophantine system solutions that John Mount describes here: we've established the linear structure, set up the correct modular relations and parameterization, and found the integral endpoints that enforce the sign constraints. Of course, in this case, the endpoints were pretty much given to us.

Now we can just fill in the table of cases. I'll even do this one by hand.

wine bottles	n	a (corner)	b (center)
60	15	6	9
56	14	7	7
52	13	8	5
48	12	9	3
44	11	10	1

And after this, of course, even our oblivious connoisseur won't be able to avoid noticing his losses.

"Half-symmetric" Solutions #

There is another set of solutions, where instead of all the corners having the same number of bottles, the diagonally opposite corners do:

This will (with some algebra) give the system:

\begin{aligned} a + c & =42-n \\ b & =n-21 \\ w & =2n \\ n & \in30:22 \end{aligned}

which in turn produces the table:

wine bottles	n	a+c	b
60	30	12	9
56	28	14	7
52	26	16	5
48	24	18	3
44	22	20	1

The point is that any combination of $a$ and $c$ that produces the correct sum will work. If $a = c$ , then we have the completely symmetric solution above.

So the thief, if he wanted to, could mix up the arrangements, to (maybe) make the thefts less apparent.

Coin Puzzles

2024-10-08T00:00:00Z

Here are a couple of puzzles from Henry Dudeney's article "The Best Puzzles with Coins," in the Strand Magazine, July 1909. These are maybe less interesting than the mathematical puzzles that John and I have been doing, but for whatever reason, they caught my eye.

Kissing Coins #

If I lay a penny flat on the table, how many other pennies can I place around it, every one also lying flat on the table, so that they all touch the first one?

It needn't be pennies, of course. Any coin (or any disc) will do, as long as all the coins in question are the same size. Try to do this one by geometry, not experiment.

Making Change #

If you split the check at restaurants a lot, then you probably have practical experience with this one, or at least you did until you and all your friends got Venmo. Remember, this puzzle is from 1909, though I've reworded it slightly.

A tourist went into a shop in New York and bought goods at a cost of thirty-four cents. The only money they had was a dollar (100 cents), a three-cent piece, and a two-cent piece.⊕ Yes! The U.S. two-cent piece and three-cent piece really existed, although by 1909 they probably weren't in circulation anymore. The seller had only a half-dollar and a quarter (25 cents). But another customer happened to be present, and when asked to help produced two dimes (dime = 10 cents), a nickel (5 cents), a two-cent piece, and a penny (1 cent). How did the seller make change?

Solutions beneath the 3-cent nickel.

Source: Wikimedia

Solutions #

Kissing Coins #

Imagine three coins of radius $r$ , and lay them out so that they all just kiss each other:

Why yes, we do have a chalkboard in our office.

Then the triangle formed by the center of the three coins is an equilateral triangle with sides $2 r$ . Each interior angle of the triangle is 60°.

360°/ 60° = 6, so we can lay out six such triangles around a center coin, where each coin just kisses its two neighboring coins. That's six coins (because every perimeter coin is in two triangles).

I didn't have any pennies to hand to demonstrate this, so I used refrigerator magnets instead..

Making change #

At the start, the allocations are:

buyer: 100¢, 3¢, 2¢, and wants to make a 34¢ purchase
seller: 50¢, 25¢
customer: 10¢, 10¢, 5¢, 2¢, 1¢

If the buyer gives the seller a dollar, then the change is 66¢, which obviously isn't going to work. So the buyer changes their 3¢ coin with the customer, for the 2¢ coin and the penny. This gives:

buyer: 100¢, 2¢, 2¢, 1¢
seller: 50¢, 25¢
customer: 10¢, 10¢, 5¢, 3¢

Now the buyer gives the seller $1.04, and needs 70¢ back. So the seller changes their quarter with the customer for two dimes and a nickel:

buyer: ~~100¢, 2¢, 2¢,~~ 1¢ and a 34¢ purchase
seller: (100¢, 2¢, 2¢) 50¢, 10¢, 10¢, 5¢,
customer: 25¢, 3¢

A half-dollar and two dimes is 70¢, so the seller can make change, and everyone is happy.

The Perplexed Banker

2024-10-03T00:00:00Z

This is from Henry Dudeney’s “Perplexities” article in the March 1925 issue of The Strand Magazine:

A man went into a bank with 1,000 silver dollars and 10 bags. He said, “Place this money, please, in the bags in such a way that if I call and ask for a certain number of dollars you can hand me over one or more bags, giving me the exact amount called for without opening any of the bags.” How was it to be done? We are, of course, only concerned with a single application, but he may ask for any exact number of dollars from 1 to 1000.

(In the original article it was “sovereigns” and “pounds”—but I’m in the U.S., so…)

This is similar in spirit to Bachet’s Four Weights Problem, so if you’ve solved that one, you should certainly be able to solve this one.

The solution is below Chirico’s The Mathematicians.

The Mathematicians (1917)
Artist: Giorgio de Chirico. Source: WikiArt

The Solution #

Unlike the weights problem, the combination of bags here is strictly additive:

\sum_{i = 1}^{10} s_{i} b_{i} = x

where $x$ is the amount the customer asks for, $b_{i}$ is the number of coins in bag $i$ , and $s_{i} \in {0, 1}$ .

So instead of a trinary system, we have a good old binary system. This means if we have $n$ bags and we put 1 coin in the first bag, 2 coins in the second bag, 4 coins in the third bag…. That is, we put $2^{i - 1}$ coins in the ith bag, we can represent any value between 0 and $2^{n} - 1$ .

Let’s demonstrate this with 3 bags, which should give us the numbers 0:7.

# fill the bags
bags = vapply(1:3, function(i) {2^(i-1)}, numeric(1))
bags

## [1] 1 2 4

# get all the possible combinations of bags
signs = c(0,1)
S = expand.grid (s1 = signs,
                 s2 = signs,
                 s3 = signs) |>
  as.matrix()

S

##      s1 s2 s3
## [1,]  0  0  0
## [2,]  1  0  0
## [3,]  0  1  0
## [4,]  1  1  0
## [5,]  0  0  1
## [6,]  1  0  1
## [7,]  0  1  1
## [8,]  1  1  1

# get the total number of coins for each combination
as.numeric(S %*% bags)

## [1] 0 1 2 3 4 5 6 7

We have 10 bags, so we can represent any value from 0 to $2^{10} - 1 = 1023$ , which is more coins than we have. The 10th bag should hold $2^{9} = 512$ coins, but since we are 23 coins short, it will only hold $512 - 23 = 489$ coins.

So the solution is: The first 9 bags hold $2^{i - 1}$ coins for $i$ from 1 to 9; and the last bag holds 489 coins.

Let’s verify that.

# fill the bags
bags = vapply(1:10, function(i) {2^(i-1)}, numeric(1))
bags[10] = 489 # the last bag is a little short.

# get all the possible combinations of bags
slist = lapply(1:10, function(i) signs)
names(slist) = paste0("bag", 1:10)

S = expand.grid (slist) |> as.matrix()
dim(S)

## [1] 1024   10

Note that there are still 1024 combinations of bags; we know that we can only represent the numbers 0:1000, so some of the totals will be duplicated. In other words, for some numbers, there are multiple combinations of bags that give the same sum.

# get the total number of coins for each combination
x = as.numeric(S %*% bags)

# find all the unique values we can achieve
x_unique = sort(unique(x))

# confirm that this gives us every value from 0 to 1000
stopifnot(x_unique==0:1000)

So we have achieved the customer’s ask, and the banker is no longer perplexed!

We can go a little further. Which sums can be achieved multiple ways?

x[duplicated(x)]

##  [1] 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
## [20] 508 509 510 511

Note that 489 is the number of coins in bag10, and 511 is $2^{9} - 1$ , which, in a proper binary representation, is the last number that wouldn't require bag10 to fulfill the sum.

For fun, let’s see the different ways to achieve x = 500

ix = which(x==500)

S[ix, ]

##      bag1 bag2 bag3 bag4 bag5 bag6 bag7 bag8 bag9 bag10
## [1,]    0    0    1    0    1    1    1    1    1     0
## [2,]    1    1    0    1    0    0    0    0    0     1

The first solution is the "standard" solution, meaning 500 encoded in binary (backwards). The second solution is because our last bag doesn't have the correct number of coins in it, and in fact has fewer than 500. You can tell it's not the standard answer because we use bag 1, meaning the answer appears to be odd. But this evens out, because bag10 has an odd number of coins in it.

Bachet’s Four Weights Problem

2024-09-29T00:00:00Z

Here’s another puzzle from Henry Dudeney’s article “The World’s Best Puzzles”, The Strand Magazine, December 1908. According to Dudeney, this puzzle is originally from Problèmes plaisans et délectables qui se font par les nombres (Pleasant and delectable number problems), by French mathematician Claude Gaspar Bachet de Méziriac (1551-1636).^[1]

A balance scale and four weights. Image Source

You have four (integral) weights $w_{1}, w_{2}, w_{3}, w_{4}$ and a balance scale such that you can weigh any object weighing from 1 lb to 40 lbs (no fractions). The weights may go on either side of the scale (eg, with the object, or in the opposite pan). What are the $w_{i}$ ?

This seems like a variation on the Frobenius coin problem, which in general is NP-hard. Fortunately, this specific instance is not.

As before, here’s Chirico’s The Mathematicians for you to look at while you try to solve this. Solution below.

The Mathematicians (1917)
Artist: Giorgio de Chirico. Source: WikiArt

The Solution #

The four weights are (1, 3, 9, 27). Before we confirm this computationally, let’s compute the solution using induction.

Let’s rephrase the problem as

You have $n$ weights… such that you can weigh any number of pounds in the range 1:m….

where $m$ depends on how many weights you have. We can also observe that the sum of all the weights must equal the weight of the heaviest object you can measure, and that object must weigh $m$ pounds.

Then for the case $n = 1$ , you have a single weight $w_{1} = 1$ , and you can weigh any object that weighs one pound (the interval 1:1). Now let’s look at the case $n = 2$ .

1. The weights $(w_{1} = 1, w_{2} = 3)$ can weigh any object from 1 to 4 pounds. #

I’ll use $x$ to denote the object to be weighed, and the notation $[{s e t_{1}} | {s e t_{2}}]$ to denote what’s on the left and the right side of the scale. I’ll always put $x$ in the right-hand pan.

$x = 1$ is weighed as $[{1} | {x}]$ . This can be written as $1 = x$ .

$x = 2$ is weighed as $[{3} | {x, 1}]$ . This can be written as $3 = x + 1$ , or $3 - 1 = x$ .

$x = 3$ is weighed as $[{3} | {x}]$ . This can be written as $3 = x$ .

$x = 4$ is weighed as $[{1, 3} | {x}]$ . This can be written as $1 + 3 = x$ .

You can see from the above that the general form of the solution is

s_{1} w_{1} + s_{2} w_{2} = x

where $(w_{1}, w_{2}) = (1, 3)$ and $s_{i} \in {- 1, 0, 1}$ . A positive coefficient means the weight is in the left pan, a negative one means it’s in the right pan, and zero means the weight isn’t used. This is essentially a “signed trinary” representation of $x$ . For two digits, signed trinary can represent $3^{2} = 9$ values.

Let’s just see what that looks like in R:

library(poorman)

signs = c(-1, 0, 1)

S = expand.grid (s1 = signs,
                 s2 = signs)
knitr::kable(S)

s1	s2
-1	-1
0	-1
1	-1
-1	0
0	0
1	0
-1	1
0	1
1	1

Let’s take the linear combination of s1 and s2, using the weights (1, 3).

S = S |>
  mutate(x = 1 * s1 + 3 *s2) 

knitr::kable(S)

s1	s2	x
-1	-1	-4
0	-1	-3
1	-1	-2
-1	0	-1
0	0	0
1	0	1
-1	1	2
0	1	3
1	1	4

You can confirm for yourself that using another pair of weights won’t necessarily give you 9 unique values.

We are only interested in the positive values for our problem. We can calculate that the number of positive values is

(3^{2} - 1) / 2 = (9 - 1) / 2 = 4.

In other words, the weights (1, 3) can weigh the values 1:4.

2. The case of three weights #

How many values can we weigh with three weights, and what are they? It’s clear that $w_{1}$ and $w_{2}$ must be the same as above, since any value in the range 1:4 can be represented as $s_{1} * 1 + s_{2} * 3 + 0 * w_{3}$ . Now to find $w_{3}$ .

We know that $3^{3} = 27$ , which means that we can represent $(27 - 1) / 2 = 13$ positive values, with 13 being the maximum. So the three weights must sum to 13, which gives us $w_{3} = 13 - (1 + 3) = 9$ . The set of weights is (1, 3, 9).

3. Finally, the case of four weights #

We can calculate that $3^{4} = 81$ , which corresponds to $(81 - 1) / 2 = 40$ positive values (surprise!). Therefore we have that $w_{4} = 40 - (1 + 3 + 9) = 27$ . And so the set of weights we want is (1, 3, 9, 27), as stated above.

Now let’s confirm it.

S = expand.grid (s1 = signs,
                 s2 = signs,
                 s3 = signs,
                 s4 = signs) |>
  mutate(x = 1*s1 + 3*s2 + 9*s3 + 27*s4) |>
  filter(x > 0)

# confirm we have the values 1:40
stopifnot(S$x == 1:40)

knitr::kable(S)

	s1	s2	s3	s4	x
42	1	0	0	0	1
43	-1	1	0	0	2
44	0	1	0	0	3
45	1	1	0	0	4
46	-1	-1	1	0	5
47	0	-1	1	0	6
48	1	-1	1	0	7
49	-1	0	1	0	8
50	0	0	1	0	9
51	1	0	1	0	10
52	-1	1	1	0	11
53	0	1	1	0	12
54	1	1	1	0	13
55	-1	-1	-1	1	14
56	0	-1	-1	1	15
57	1	-1	-1	1	16
58	-1	0	-1	1	17
59	0	0	-1	1	18
60	1	0	-1	1	19
61	-1	1	-1	1	20
62	0	1	-1	1	21
63	1	1	-1	1	22
64	-1	-1	0	1	23
65	0	-1	0	1	24
66	1	-1	0	1	25
67	-1	0	0	1	26
68	0	0	0	1	27
69	1	0	0	1	28
70	-1	1	0	1	29
71	0	1	0	1	30
72	1	1	0	1	31
73	-1	-1	1	1	32
74	0	-1	1	1	33
75	1	-1	1	1	34
76	-1	0	1	1	35
77	0	0	1	1	36
78	1	0	1	1	37
79	-1	1	1	1	38
80	0	1	1	1	39
81	1	1	1	1	40

And we are done. At this point, I’ll note that we’ve just re-invented a signed base-3 number system: digit $i$ (counting from zero) represents the value $3^{i}$ . I just happened to be writing it backwards.

Among Bachet’s accomplishments are a method of constructing magic squares; a way of solving indeterminate equations with continued fractions; the proof of Bézout’s Identity; and a Latin translation of Arithmetica by Diophantus (he of the Diophantine equations). Famously, Fermat’s last theorem was a scribbled margin note on his copy of this very translation. ↩︎

100 Bushels of Corn

2024-09-26T00:00:00Z

I was browsing the December, 1908 issue of The Strand Magazine (it’s related to a hobby of mine), when I came across an article called “The World’s Best Puzzles”, by Henry Dudeney, who seems to have been the Martin Gardner of his day. Here’s a cool puzzle from that article, which according to Dudeney was first recorded by Alcuin, Abbot of Canterbury (735-804). I assume it’s from his manuscript Propositiones ad Acutendos Juvenes (Problems to Sharpen Youths).

The Puzzle #

100 bushels of corn are distributed to 100 people such that every man receives 3 bushels, every woman 2 bushels, and every child 1/2 a bushel. How many men, women, and children are there?

There are seven solutions; Dudeney gives one: 20 men, 0 women, and 80 children. Can you find the other six?

Let’s put the puzzle into algebra, so it’s easier to discuss.

\begin{aligned} m + w + c & =100 \\ 3 m + 2 w + 0.5 c & =100 \end{aligned}

Solve for $m$ , $w$ , and $c$ .

This problem (or one very close to it), is known as a system of Diophantine equations.

Here’s a picture to look at while you try to solve it. The answer is below. Don’t peek!

The Mathematicians (1917)
Artist: Giorgio de Chirico. Source: WikiArt

The Solution #

Here’s my solution. I’ll break it into steps. From the problem statement, we know $m$ , $w$ , and $c$ are all nonnegative integers.

1. $c$ is even. #

That there is an even number of children is obvious from the fact that the total number of bushels is integral, and that the number of men, women, and children all have to be integral.

2. $w$ is a multiple of 5. #

To prove this, we take the two original equations and eliminate $m$ , by multiplying the first equation by $- 3$ and adding the two together.

\begin{aligned} - 3 m & -3w & -3c & =-300 \\ 3 m & +2w & +0.5c & =100 \end{aligned}

this gives us:

\begin{aligned} - w - 2.5 c & =-200 \\ w + 2.5 c & =200 \end{aligned}

Another way to write the last equation is

w + (5 / 2) c = 200

Since $c$ is even, $(5 / 2) c$ is divisible by 5, and 200 is divisible by 5; therefore, $w$ is divisible by 5. QED

3. $w \leq 30$ #

To prove this, let’s eliminate $c$ .

\begin{aligned} - 0.5 m & -0.5w & -0.5c & =-50 \\ 3 m & +2w & +0.5c & =100 \end{aligned}

this results in:

\begin{aligned} 2.5 m & +1.5w & +0 & =50 \\ 5 m & +3w & +0 & =100 \end{aligned}

which gives us

m = 20 - (3 / 5) w

Now we apply the fact that $m \geq 0$ :

\begin{aligned} 20 - (3 / 5) w & \geq0 \\ (3 / 5) w & \leq20 \\ 3 w & \leq100 \\ w & \leq100/3=33.333... \end{aligned}

And since we know that $w$ must be a multiple of 5, this gives us $w \leq 30$ . QED

What are the multiples of 5 that are less than or equal to 30?

w = seq(from=0, to=30, by=5)
w

## [1]  0  5 10 15 20 25 30

That’s 7 values—exactly what we’re looking for! So we’re basically done, but we can fill in all the counts just to polish it off. I’ll do that in R, but you can do it in any language, of course.

# from Step 3
m = 20 - (3/5) * w

# from the fact that there are 100 people total
c = 100 - (m + w)

pframe = data.frame(
  men = m,
  women = w,
  children = c,
  total_pop = m+w+c,
  bushels = 3*m + 2*w + 0.5*c
)

knitr::kable(pframe, caption="Allocations of men, women, and children")

men	women	children	total_pop	bushels
20	0	80	100	100
17	5	78	100	100
14	10	76	100	100
11	15	74	100	100
8	20	72	100	100
5	25	70	100	100
2	30	68	100	100

Allocations of men, women, and children

And there you have it: the seven solutions to the “100 bushels of corn” problem.

I Added Margin Notes to my Blog

2024-09-07T00:00:00Z

Note: This post is best seen on my site, on a desktop/laptop. Mobile and RSS readers won't show you all the margin-y goodness.

Because I can't leave a challenge alone, I added basic margin notes to this blog. The approach is basically from Tufte-CSS, and I now have both (unnumbered) margin notes⊕ Following Tufte, I'll use margin note for unnumbered marginalia, and side note for numbered ones. and standard footnotes. Here's an example page to show it off.

And here's a sneak preview of how to add a margin note:⊕ It took me a bit to find out how to escape the shortcode in this code snippet.


Here is some text{% marginnote "demo", "This is a note." %} to annotate.

Which produces:

Here is some text⊕ This is a note. to annotate.

~~Although, as you can see, I don't have it working quite right with notes in blockquotes. Later....~~ [Fixed it.]

Deciding on the Approach #

When deciding whether and how to do this, I had a couple of criteria for an acceptable solution:

It had drop into the blog with minimal template tweaking.
It had to be maintainable and not magic.

This eliminated both eleventufte and tufte-markdown, the parser that powers eleventufte, since the tufte-markdown project is no longer actively maintained. Sure, it works now; but if/when it ever stops working, I can't fix it. It also eliminated the javascript solution from Mark Llobrera that I discussed in my last post. His particular implementation felt tightly coupled to his grid-based blog layout; and while a better web developer than I could probably decouple them, I can't, and I'm not overhauling my entire blog, either.

Going straight to the implementation in Tufte-CSS seemed the best. I just hoped I had enough CSS know-how to figure it out.

Let's do it! #

Adding the markdown CSS was not as painful as I thought it would be. I'll walk through it now, somewhat slowly, for the benefit of any readers at my level of non-expertise, who might be considering this. The discussion will be in the context of my static blog generator, eleventy; but the process should be generalizable to other frameworks.

1. Add `marginnote.css` to wherever your blog keeps its stylesheets. #

Here's my CSS, marginnote.css, which is stripped down and slightly modified from the original tufte.css. What it does, in English: Assume your annotated content is in an article container. Then the stylesheet defines the major content containers (p, pre, ul and blockquote) to only occupy a fraction of the article container's width (65%, for me), on the left. The marginnote container can then float to the right side, into the empty space. The stylesheet also adjusts img and image captions to only occupy the content space (not the note space).

There's also a fallback for narrow viewports, like mobile. When the viewport is too narrow to hold the margin notes, a little symbol, ⊕ (that's "⊕"), appears next to where the margin note is anchored (like the number on a footnote). Clicking on the symbol toggles the note on and off, inline. Try it: just narrow your browser window until the margin notes disappear; you should see the little markers where the notes should be.

If you are thinking about doing this, you can start with my stylesheet, and adjust the variables to suit your blog.⊕ If you are truly a novice at this, as I am, it can be helpful to put colored borders around the body, paragraph, and marginnote containers. This helps you visualize how changes to offsets, margins, and paddings affect the layout. Note that this template assumes you'll only use <article> for potentially annotated content (in my case, only posts). If you use article for other purposes, you'll probably have to create a special class---<article class="annotated">, or something---and modify the css accordingly.

2. Modify the post template. #

It seems reasonable to assume I'll only need margin notes in blog posts, which is good -- I can localize my changes. I use Nunjucks to define my layout, so I made a couple of changes to my template, post.njk.⊕ I created a simple annotated page template, too, but the example I linked to above is probably the only time I'll ever use it.

1. I included the css, of course:


{%- css %}{% include "public/css/marginnote.css" %}{%- endcss %}

2. Then I wrapped the post content in an article container:


{# wrap the content in an article container so that the margin notes work #}
<article>
  {{ content | safe }}
</article>

3. (If needed) Widen the body width. #

You might want to widen the width of your content area to accomodate the notes. I suppose I could have made my article container wider than my body, but then I'd have to fiddle with alignments and stuff. I just widened the entire blog. Presumably, the setting is in your primary stylesheet.

body {
	max-width: 70em; /* used to be 50em */
}

That was all that was truly necessary. I did restrict the widths of a couple of other container classes back down to 50em, but that was strictly for aesthetic reasons. The site certainly wouldn't break if I'd left them at their defaults.

This now gives you margin notes, if you are willing to put the html in your posts by hand (I know you're not, but I think it helps to see the steps). That would look like this:

This is some text<label for="note-id" class="margin-toggle">&#8853;</label>
			   <input type="checkbox" id="note-id" class="margin-toggle"/>
			   <span class="marginnote">This is the note.</span> 
to annotate.

This is some text⊕ This is the note. to annotate.

Yeah, it's ugly, but that's how the Tufte-CSS folks designed it. Hence, the shortcode. If I were really clever, I'd figure out how to redefine the footnote syntax; but I'm not really clever. I assume redefining the footnote notation is what tufte-markdown does, but as I said above, that's not an option.

4. Define the shortcode. #

For eleventy, this goes in eleventy.config.js, or eleventy.js, depending on how your site is set up. For other frameworks, consult your documentation.

module.exports = function(eleventyConfig) {

    // lots of config, blah blah blah...

    // shortcode for adding margin notes
    eleventyConfig.addShortcode('marginnote', 
        (id, content) => 
            `<label for="${id}" class="margin-toggle">&#8853;</label>
            <input type="checkbox" id="${id}" class="margin-toggle"/>
            <span class="marginnote">${content}</span>`
        
    );

    // more config ...
}

The shortcode has two arguments: an id for the note, and the note content, which is a string of markdown. You can include links or formatting. The id matches the toggle to the note in narrow mode, so make them unique, or a single toggle will hide/display multiple notes on the page. The ugly html example above then becomes:


This is some text{% marginnote "note-id", "This is the note." %} to annotate.

And that's it! You can now annotate your posts with marginalia!

Shortcomings of the approach #

Only margin notes, and only short ones. #

Tufte-CSS includes both (numbered) sidenotes and (unnumbered) margin notes. With the sidenotes, in narrow mode, the toggling was attached to the number, as with a footnote. I could get the sidenotes to appear in the margin, but I couldn't make them toggle in narrow mode. I'm not sure why. My best guess is that something in my main css was clobbering it. It was too much work to figure that out, and maybe it's for the best. If I did have them, I'd have to figure out how to set different numbering systems (1,2,3; a,b,c...) for the sidenotes and the footnotes.

Because it's good to still have the footnotes! Unlike the javascript-based solution that I used for Twelve Medieval Ghost Stories, this CSS-only solution will not prevent notes from overlapping if they are too close together or too long. So having standard footnotes is still the right solution for lengthy notes, like the note in this post.⊕ That's also a multi-paragraph note, which I just discovered you can do! With footnotes only, not margin notes.

They don't cos-play as footnotes. #

The javascript-based solution at Twelve Medieval Ghost Stories uses standard footnote notation in the markdown, and a footnote class that can switch between a sidenote and footnote appearance as necessary. This means sidenotes "degrade" gracefully to standard footnotes on mobile, and presumably, in RSS readers. Though I admit, I've never checked.

This solution degrades gracefully on mobile, but I suspect a lot of readers won't realize the "⊕" symbol marks the presence of a note, so the notes effectively get lost. And I don't think RSS readers will handle them well at all. ~~In fact, I shudder to think how this post must look in RSS, since I've been profligate with notes (after all, now that I have them...).~~ [EDIT: I just took a look at my RSS, on Reeder. The little symbols show up, along with the checkbox that is the actual toggle, but the notes don't toggle on; so they are lost. But at least the primary text is still readable.] But, well, what's the point of having a nice-looking blog if no one's going to look at it? Click through to people's sites, sometimes, folks!

On the positive side... #

For obscenely long articles (like this one), margin notes (or sidenotes) are clearly preferable. They save the reader from having to constantly click back and forth from the text to the note, which I suspect most readers don't. I've always wanted them, and now I can check them off my "nice-to-have" list.

Playing With Sidenotes

2024-09-04T00:00:00Z

For no particular reason, I started wondering if I could add sidenotes to my blog. I've always liked them better than endnotes, especially for longer documents. This led me to the more general question: Is there an eleventy template for sidenotes?

The answer is yes. But before plunging in, I decided to try a fresh blog first. My repository of medieval ghost stories (forked from an earlier repo) seemed like a useful test case.

It was also a hard test case: these are scholarly documents, and the notes are long and dense -- exactly the case that Tufte-CSS based sidenote solutions don't handle well. I ended up using a javascript based solution that I found on the web.

The result is the Twelve Medieval Ghost Stories website.

It looks great; the sidenotes work really well, and drop down to regular endnotes on narrow browsers. But the grid-based paradigm this solution uses seems really brittle, and I don't want to restructure my entire blog template to support it.

So back to thinking about Tufte-CSS. But this wasn't a waste; I've learned some potentially useful things, and this is a fairly nice presentation of the ghost stories. I'll just let it percolate in my head for a little longer.

Adjusting Saturated Multivariate Linear Models

2024-08-20T00:00:00Z

This is a followup to the Win Vector blog article Post-hoc Adjustment for Zero-Thresholded Linear Models, in which I showed how to use a one-variable GAM (e.g., a spline) to adjust a linear model in a problem space where outcomes are strictly nonnegative. If you haven’t read that article, I suggest you check it out, first.

Some Background #

The original motivation for the work we did here was to help a client who had built a fairly complex multivariate model to predict expected count data. Their underlying assumption was that in their domain, a count of zero is a rare event. To quote my previous article:

When you don’t expect to see too many zeros in practice, modeling the process as linear and thresholding negative predictions at zero is not unreasonable. But the more zeros (saturations) you expect to see, the less well a linear model will perform.

They then automated the model training and deployment process, and put it into production across multiple sites.

Unfortunately, zero-counts are not so rare as they originally believed, at some of their sites. Because coming up with and deploying a new model design is not necessarily feasible at this stage (at least not in the immediate term), they wanted to figure out how to adjust their existing models to operate even at high zero-count sites. Note that this adjustment is a one-dimensional process: mapping the output of one model to a prediction that is closer to the actual outcomes.

To motivate this adjustment process in the previous article, I used an example of a linear model that was fit to a one-dimensional saturated process. This was so I could plot the resulting “hockey stick” function, and show what happens with different model adjustments. But it’s been my experience that people won’t believe that this procedure will generalize to multivariate linear models, unless I show them that it works on such models. So in this article, I’ll apply the same procedures to a linear model that was fit to two variables, just to prove the point.

I’ll also add an additional adjustment that wasn’t in the original article, but was suggested by Neal Fultz: adjustment using a Tobit model. You can see more details of that in a revised version of the article on github, here. Tobit adjustments work nearly as well as GAM adjustments, and do have the (potential) advantage of having a stronger inductive bias, if you believe that your process is truly linear in its non-saturated regions ^[1].

In the second part of the article, I’ll try fitting a model directly to the input data, using both GAM and Tobit, since ideally, that’s what you’d do if you were approaching this modeling task de novo.

For legibility and brevity, I’m going to hide a lot of the code when generating this article, but you can find the original R Markdown source code on github as well, here.

Example Problem #

Here are the characteristics of our example problem:

The feature u positively correlates with outcome, while v negatively correlates.
The outcome y is constrained to be nonnegative; in other words, it “saturates” at zero.
Both features u and v are bounded between 0 and 1 uniformly.
There is a moderate noise process on top of it.

trueprocess = function(N) {
  u = runif(N)
  v = runif(N)
  noise = 0.3 * rnorm(N) 
  y = pmax(0, 4 * u - 3 * v + noise)
  data.frame(u = u, v = v, y = y)
}

The Data #

Let’s generate some training data.

traind = trueprocess(1000)
head(traind)

    ##           u         v         y
    ## 1 0.1634115 0.2125462 0.6570359
    ## 2 0.5249624 0.6152054 0.0000000
    ## 3 0.3051476 0.9153664 0.0000000
    ## 4 0.9277528 0.8064937 1.5395565
    ## 5 0.5715193 0.9990540 0.0000000
    ## 6 0.2602110 0.5206304 0.0000000

Let’s plot a heatmap of the training data. Note that there’s lots of saturation.

We’re going to use all the data to train our models, but it’s not easy to show comparison plots in three dimensions in a way that’s legible. So we’ll also look at slices of the data, by holding u restricted to a narrow range around a nominal value. Here’s a slice with u fixed to near 0.5.

As you can see, the data is fairly noisy, in addition to being quite saturated. Now let’s train a linear model on the data, as well as all our adjusted models.

Part I: Adjustments to a Linear Model #

Train the initial model, and all the adjustments #

We’ll fit the model, make the naive adjustment of thresholding the data at zero, then fit all the candidate adjustment models. Note that only the initial model ever makes reference to the input variables.

# train the initial model, 
# get the initial predictions and thresholded predictions

initial_model = lm(y ~ u + v, data=traind)
traind$y_initial= predict(initial_model, newdata=traind)
traind$y_pred0 = pmax(0, traind$y_initial)

# fit the adjustment models
# (function definitions in R markdown document)
scaling_model = fit_scaler(initial_model, "y", traind)
linadj_model = fit_linmod(initial_model, "y", traind)
gamadj_model = fit_gammod(initial_model, "y", traind)
tobitadj_model = fit_tobit(initial_model, "y", traind)

adjustments = list(scaling_model, linadj_model, gamadj_model, tobitadj_model)
names(adjustments) = c("y_linscale", "y_linadj", "y_gamadj", "y_tobitadj")

# make the predictions
for(adj in names(adjustments)) {
  traind[[adj]] = do_predict(adjustments[[adj]], newdata=traind)
}

Let’s look at the RMSE and bias of each model.

prediction_type	description	RMSE	bias
initial	initial model	0.4438901	0.0000000
pred0	zero-thresholded model	0.3721101	0.0842275
linscale	scale-adjusted model	0.3692881	0.1196263
linadj	linear-adjusted model	0.2453422	0.0298617
gamadj	GAM-adjusted model	0.2261695	0.0007868
tobitadj	Tobit-adjusted model	0.2293762	-0.0097394

Model RMSE and bias on training data

As expected (if you’ve read the previous article), the GAM-adjusted model has the lowest training RMSE, and also lower bias than the other adjusted models. The Tobit-adjusted model has comparable RMSE, and slightly more bias.

We can try to visualize what’s happening, by holding u constant at different values and looking at slices of the prediction surfaces. We’ll just compare the original linear model, GAM-adjustment, and Tobit-adjustment.

Test on holdout #

Let’s compare the models on holdout data. For this example the holdout performances are similar to training.

testd = trueprocess(5000)

testd$y_initial= predict(initial_model, newdata=testd)
testd$y_pred0 = pmax(0, testd$y_initial)
for(adj in names(adjustments)) {
  testd[[adj]] = do_predict(adjustments[[adj]], newdata=testd)
}

prediction_type	description	RMSE	bias
initial	initial model	0.4504353	-0.0046703
pred0	zero-thresholded model	0.3750385	0.0836604
linscale	scale-adjusted model	0.3721833	0.1184737
linadj	linear-adjusted model	0.2482977	0.0310791
gamadj	GAM-adjusted model	0.2285600	0.0043918
tobitadj	Tobit-adjusted model	0.2300590	-0.0064108

Model RMSE and bias on holdout data

Part II : Fitting directly to the input data #

Now let’s try both Tobit and GAM directly on the input data. There are, of course, other methods we could try, like Poisson or Zero-inflated Poisson regression. But since we’ve been focusing on Tobit and GAM as adjustments, we’ll just stick to those.

Note that since neither of these models are restricted to nonnegative predictions, we still have to threshold to zero.

Let’s fit to our training data.

gam_model = gam(y ~ s(u) + s(v), data=traind)
traind$y_gam = pmax(0, predict(gam_model, newdata=traind))

tobit_model = vglm(y ~ u + v, tobit(Lower=0), data=traind)
traind$y_tobit = pmax(0, predict(tobit_model, traind)[, "mu"])

We’ll compare the full model fits to the GAM-adjusted and Tobit-adjusted linear models.

prediction_type	description	RMSE	bias
gamadj	GAM-adjusted model	0.2261695	0.0007868
tobitadj	Tobit-adjusted model	0.2293762	-0.0097394
gam	Full GAM model	0.3505055	0.0668857
tobit	Full Tobit model	0.2280450	-0.0099883

Model RMSE and bias on training data

The full (thresholded) Tobit model does essentially as well as the Tobit-adjusted linear model, but the thresholded GAM doesn’t do so well. Since this problem is truly linear, the stronger inductive bias of the Tobit model serves us well.

Test on holdout #

We can also evaluate these models on holdout data.

prediction_type	description	RMSE	bias
gamadj	GAM-adjusted model	0.2285600	0.0043918
tobitadj	Tobit-adjusted model	0.2300590	-0.0064108
gam	Full GAM model	0.3574985	0.0658623
tobit	Full Tobit model	0.2280260	-0.0072236

Model RMSE and bias on holdout data

We get similar results. We can plot some slices to get an idea of what’s happening.

Conclusions #

For our original problem—post-hoc adjustments of an already established modeling procedure—a GAM adjustment seems to be the best way to adapt our modeling to higher-than-anticipated saturation frequency. However, Tobit adjustment is competitive. If you have the opportunity to design the modeling procedure de novo, GAM may not be the best option; though I admit, I didn’t spend any time trying to tune the model. If the process you are modeling is well-approximated as linear in the non-saturated region, then a thresholded Tobit model appears to be a good choice.

Obviously, to fit a full model, one can try many more methods: Poisson regression, trees, MARS, boosting, random forest, and so on. A typical task for the data scientist is to try many plausible methods on the client’s data and pick the one that appears to be the best practical trade-off for the given client.

Statisticians generally use the word “censored” when talking about processes that threshold out to a minimum or maximum value (or both). Often, the assumption is that the measurements are censored because of limitations of the measurement itself: for example, you can’t track a subject for more than five years, so the longest lifetime you can expect to measure is 5, even if the subject lives for decades longer. Models like Tobit try to predict as if the data isn’t censored: they can predict a lifetime longer than 5 years, even though those lifetimes can’t be measured.

I am using the word “saturated” to indicate that the outcome being measured literally cannot go beyond the threshold: counts can never be negative. A possibly useful analogy is the image from a digital camera: too much light “blows out” the photo. If you are trying to predict the intensity of the light that hit the camera sensor using the image pixels as the outcome data, then the data is censored. If you are trying to predict the values of the pixels, then the data is saturated. ↩︎

Simpson’s Paradox as a Logistic Regression

2024-07-16T00:00:00Z

Simpson’s paradox is when a trend that is present in various groups of data seems to disappear or even reverse when those groups are combined. One sees examples of this often in things like medical trials, and the phenomenon is generally due to one or more unmodelled confounding variables.

In the course of something else that I was working on, I was trying to come with an example of a logistic regression analysis, where one of the coefficients had a clearly incorrect sign. There are several reasons why this might happen: separation or quasiseparation of the data being the obvious ones. But Simpson’s paradox is another cause.

I ended up not needing the example, but since I had it, I thought I’d write it up, since I’ve never seen Simpson’s paradox presented in quite this way before.

Synthetic Example: Weight Loss Trial #

This is a problem statement where we would expect the coefficients of a logistic regression to be non-negative (except the intercept).

Consider a trial that tests the efficacy of a specific eating regimen (let’s say 16/8 intermittent fasting, which we’ll call ifasting) and a specific exercise regimen (a brisk 30 minute walk every day, which we’ll just call exercise). The goal (“success”) is to lose at least five pounds by the end of the trial period. We’ve set up three treatment groups, as follows:

200 subjects try exercise alone
300 subjects try ifasting alone
300 subjects try ifasting plus exercise

Prior to the trial, all the subjects led fairly sedentary lifestyles, and weren’t dieting in any formal way.

For these subjects, one might reasonably expect that neither exercise nor ifasting would be less successful for losing weight than doing nothing. One would also reasonably expect that ifasting plus exercise should do no worse than doing either one alone. Therefore, modeling the results of such an experiment as a logistic regression should lead to a model where the coefficients $β_{i f a s t i n g}$ and $β_{e x e r c i s e}$ are both non-negative, as any treatment should increase the odds that the subject loses weight.

Let's show an example where our expectations aren't met, in R.

Trends for individual subpopulations #

Suppose that, unbeknownst to the researchers, there are two subpopulations amongst the subject. The first, Population A, responds quite well to the intermittent fasting regimen.

generate_samples = function(ifasting, exercise, total, successes, label) {
  failures = total-successes
  data.frame(ifasting = ifasting,
             exercise = exercise,
             success = c(rep(1, successes), rep(0, failures)),
             label=label)
}

# population A
popA = data.table::rbindlist(list(
  generate_samples(ifasting=0, exercise=1, total=100, successes=2, "A"),
  generate_samples(ifasting=1, exercise=0, total=200, successes=160, "A"),
  generate_samples(ifasting=1, exercise=1, total=100, successes=90, "A")
))

# model just on population A
mA = glm(success ~ ifasting + exercise, data=popA, family=binomial)
summary(mA)


    ## 
    ## Call:
    ## glm(formula = success ~ ifasting + exercise, family = binomial, 
    ##     data = popA)
    ## 
    ## Coefficients:
    ##             Estimate Std. Error z value Pr(>|z|)    
    ## (Intercept)  -4.7028     0.8078  -5.822 5.82e-09 ***
    ## ifasting      6.0890     0.7882   7.725 1.12e-14 ***
    ## exercise      0.8109     0.3773   2.149   0.0316 *  
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ## 
    ## (Dispersion parameter for binomial family taken to be 1)
    ## 
    ##     Null deviance: 527.16  on 399  degrees of freedom
    ## Residual deviance: 284.79  on 397  degrees of freedom
    ## AIC: 290.79
    ## 
    ## Number of Fisher Scoring iterations: 6

As expected, the coefficients for ifasting and exercise are both positive. We can look at the rates that the model predicts.

# small frame to represent all possible states
testdata = data.frame(
  ifasting = c(0, 0, 1, 1),
  exercise = c(0, 1, 0, 1)
)

# get the success rates for each state
testdata$predictA = predict(mA, newdata=testdata, type="response")
testdata


    ##   ifasting exercise    predictA
    ## 1        0        0 0.008988764
    ## 2        0        1 0.020000000
    ## 3        1        0 0.800000000
    ## 4        1        1 0.900000000

# confirm it by doing the averages by hand
library(poorman, warn.conflicts = FALSE) # for data-wrangling; uses dplyr API

popA |> 
  mutate(gp = ifelse(ifasting & exercise, 'both',
                     ifelse(ifasting, 'ifast alone', 'exercise alone'))) |>
  group_by(gp) |>
  summarize(success_rate = mean(success))


    ##               gp success_rate
    ## 1           both         0.90
    ## 2 exercise alone         0.02
    ## 3    ifast alone         0.80

For Population A, exercise alone has a 2% success rate, intermitting fasting an 80% success rate, and both together have a 90% success rate.

There is also another population, Population B, that has what you might call a “stickier” metabolism. For them, intermittent fasting is not quite as effective.

popB = data.table::rbindlist(list(
  generate_samples(ifasting=0, exercise=1, total=100, successes=1, "B"),
  generate_samples(ifasting=1, exercise=0, total=100, successes=40, "B"),
  generate_samples(ifasting=1, exercise=1, total=200, successes=100, "B")
))

# model just on population B
mB = glm(success ~ ifasting + exercise, data=popB, family=binomial)
summary(mB)

    ## 
    ## Call:
    ## glm(formula = success ~ ifasting + exercise, family = binomial, 
    ##     data = popB)
    ## 
    ## Coefficients:
    ##             Estimate Std. Error z value Pr(>|z|)    
    ## (Intercept)  -5.0006     1.0353  -4.830 1.36e-06 ***
    ## ifasting      4.5951     1.0149   4.528 5.97e-06 ***
    ## exercise      0.4055     0.2483   1.633    0.103    
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ## 
    ## (Dispersion parameter for binomial family taken to be 1)
    ## 
    ##     Null deviance: 519.18  on 399  degrees of freedom
    ## Residual deviance: 423.06  on 397  degrees of freedom
    ## AIC: 429.06
    ## 
    ## Number of Fisher Scoring iterations: 7

testdata$predictB = predict(mB, newdata=testdata, type="response")
testdata

    ##   ifasting exercise    predictA    predictB
    ## 1        0        0 0.008988764 0.006688963
    ## 2        0        1 0.020000000 0.010000000
    ## 3        1        0 0.800000000 0.400000000
    ## 4        1        1 0.900000000 0.500000000

For Population B, the coefficients for ifasting and exercise are still positive, but smaller, and the success rates are lower.

Trends for the whole population #

Now what happens if we model both populations together?

popAll = data.table::rbindlist(list(popA, popB))
mAll = glm(success ~ ifasting + exercise, data=popAll, family=binomial)
summary(mAll)

    ## 
    ## Call:
    ## glm(formula = success ~ ifasting + exercise, family = binomial, 
    ##     data = popAll)
    ## 
    ## Coefficients:
    ##             Estimate Std. Error z value Pr(>|z|)    
    ## (Intercept)  -4.0380     0.6062  -6.661 2.72e-11 ***
    ## ifasting      4.7311     0.5937   7.969 1.60e-15 ***
    ## exercise     -0.1466     0.1713  -0.856    0.392    
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ## 
    ## (Dispersion parameter for binomial family taken to be 1)
    ## 
    ##     Null deviance: 1108.79  on 799  degrees of freedom
    ## Residual deviance:  807.36  on 797  degrees of freedom
    ## AIC: 813.36
    ## 
    ## Number of Fisher Scoring iterations: 6

Now exercise has a negative coefficient, making it appear that intermittent fasting and exercise together has worse outcomes than intermittent fasting alone!

testdata$predictAll = predict(mAll, newdata=testdata, type="response")
testdata

    ##   ifasting exercise    predictA    predictB predictAll
    ## 1        0        0 0.008988764 0.006688963 0.01732739
    ## 2        0        1 0.020000000 0.010000000 0.01500000
    ## 3        1        0 0.800000000 0.400000000 0.66666667
    ## 4        1        1 0.900000000 0.500000000 0.63333333

This is an example of how Simpson’s paradox might manifest itself in a logistic regression model, and it’s due to the unmodelled confounding variable, population type. This, plus some bad luck in the relative sizes of the treatment groups with respect to population type, lead to the above, counterintuitive, results.

Simpson’s paradox isn’t the only reason for a coefficient with an unexpected sign; this can also happen when the data is separated or quasi-separated. In our case, this would happen if any of the treatment groups perfectly predicted outcome (that is, if any treatment group completely succeeded or completely failed). Let’s check for that.

popAll |> 
  mutate(gp = ifelse(ifasting & exercise, 'both',
                     ifelse(ifasting, 'ifast alone', 'exercise alone'))) |>
  group_by(gp) |>
  summarize(success_rate = mean(success))

    ##               gp success_rate
    ## 1           both    0.6333333
    ## 2 exercise alone    0.0150000
    ## 3    ifast alone    0.6666667

So separation isn’t the problem; the unmodelled confounding variable is.

Resolving the issue #

When faced with a counterintuitive result, try to determine if there's a factor you're not taking into account.

In this example, if the researchers did have access to the subjects’ population type, then they could control for that in the modelling.

mAllplus = glm(success ~ ifasting + exercise + label, data=popAll, family=binomial)
summary(mAllplus)

    ## 
    ## Call:
    ## glm(formula = success ~ ifasting + exercise + label, family = binomial, 
    ##     data = popAll)
    ## 
    ## Coefficients:
    ##             Estimate Std. Error z value Pr(>|z|)    
    ## (Intercept)  -4.1433     0.6156  -6.731 1.69e-11 ***
    ## ifasting      5.5836     0.6154   9.073  < 2e-16 ***
    ## exercise      0.5231     0.2037   2.568   0.0102 *  
    ## labelB       -1.9172     0.2103  -9.118  < 2e-16 ***
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ## 
    ## (Dispersion parameter for binomial family taken to be 1)
    ## 
    ##     Null deviance: 1108.79  on 799  degrees of freedom
    ## Residual deviance:  709.51  on 796  degrees of freedom
    ## AIC: 717.51
    ## 
    ## Number of Fisher Scoring iterations: 7

As expected, both ifasting and exercise now have positive (and significant, to p=0.05) coefficients, indicating that both actions increase the probability of weight loss, and doing them both increases it even more.

The model also correctly identifies that subjects of population type B have a (significantly) lower success rate than subjects from Population A.

Algorithmic Art

2024-05-27T00:00:00Z

...or, what nowadays one might call "non-AI generative art." Over this Memorial Day weekend, I played with a few simple algorithms, inspired by an old Stack Exchange code golf. The intention here isn't to stomp on AI-based generative art, but just to remember the simple pleasures of creating pretty pictures with math.

The details are all at the github repository, but I thought I'd share some examples here.

Generate Images with Color Similarity #

This is inspired by the code golf submission from user fejesjoco, though it's not the same. I pick a initial pixel and color at random, then place each subsequent color such that it's nearest to the colors of its filled neighbors. The "neighbor distance" metric is the minimum distance from all of a pixel's filled neighbors.

The original list of colors was the 32768 15-bit colors, and the idea was to fill a 256x128 image such that every pixel had a unique color. Here's what that looks like (resized to a square):

I can also generate images using another image as the color source. You can see more examples in my example notebook.

This algorithm generates lovely pictures, but it's fairly slow, since it must visit every point on the canvas multiple times, and do calculations each time.

Generate Images with a Series of Random Walks #

Again, the goal here is to fill the image with unique pixel colors. I pick a start point and a start color at random, then sort the colorlist by distance from the starting point. Then the starting point picks a random direction (up/down/left/right) to go. If the next pixel hasn't been filled, then we step there, filling it with the next color on the list. This continues until we reach a dead end (a point where all the neighbors are already filled). Then we pick another random (unfilled) starting point and (unused) starting color, and take another walk. This continues until every color has been used, which also colors every pixel.

That looks like this (again, resized to a square):

This one is not quite as pretty (to my mind), but it's a little faster. With good bookkeeping, you only visit every point once, with no calculation, other than the color re-sorting at the beginning of a walk. The problem is that (as we will see), a random walk crosses itself quite frequently if left alone, and we do reach dead ends quite a lot with this procedure. So I wouldn't call it fast.

There are more examples in the example notebook.

Random Walk of a Bug in Paint #

Let's give up on filling every pixel of the image, though we will walk through all the colors on our colorlist. This time, we'll put a "bug" (a point) on a square plate, and let it randomly walk around (up/down/left/right), with crossings. Each footstep is a different color from the colorlist. This is quite fast, and can produce some pretty pictures.

Here, I started at a random point with a random color from the 15-bit colorlist, and then sorted the colorlist by distance from the starting color. You can also get some interesting effects by walking the colors from a source image with no re-sorting. Here's what happened when I used this image

Greeting by Chiefs (1928). Artist: Arman Manookian
Source: WikiArt

and traversed the colors from the painting in order, line by line, as my bug wandered its plate:

The primary reason I implemented this was to animate the walk, so my function produces (fairly large) animated gifs, in addition to the final image. Here's an animation of the above image being created. You can see how often the bug walks over the same area of the plate. This will give you an idea of why filling the image space by random walk takes so long.

You can see more examples in the example notebook. There's also more here, including the gif-to-mp4 conversion code. The mp4s tend to be much smaller than the original gifs.

And that's my weekend so far! Hope yours has been fun, too.

Stupid LLM Tricks, Statistics Version

2024-03-01T00:00:00Z

I recently posted elsewhere about something silly ChatGPT did when we asked it about states' names. Admittedly, that particular question was merely on the level of cocktail party conversation, or a bar bet; but it does point out that you really should never trust anything it says, unless you already know the answer.

Here's what happened when we asked it a statistics question:

User
What are some good examples of continuous probability distribution functions with negative skew?

A distribution with negative skew looks like below: tail to the left, the bulk of the distribution to the right (generally, the median is to the right of the mean). There are several real-life distributions with negative skew, but we were looking for a continuous "closed-form" distribution (with non-negative support, though that part didn't make it into the question).

Here's the answer we got:

Skewness in a probability distribution refers to its asymmetry. A negative skew indicates that the left tail of the distribution is longer or fatter than the right tail, with the bulk of the distribution concentrated on the right side. Some examples of continuous probability distribution functions with negative skew include:

Gamma Distribution: Depending on the parameters, the gamma distribution can exhibit negative skewness, especially when the shape parameter is less than 1.

F Distribution: The F distribution can have negative skewness, particularly when the degrees of freedom for the numerator are small compared to the denominator.

Exponential Distribution: While the exponential distribution is often positively skewed, it can exhibit negative skewness for certain parameter values.

Log-Normal Distribution: In some cases, the log-normal distribution can be negatively skewed, especially when the underlying normal distribution has a mean less than 1.

Chi-Squared Distribution: The chi-squared distribution can have negative skewness for small degrees of freedom.

These distributions can be useful in modeling various phenomena where negative skewness is observed, such as in certain financial data or in certain types of measurement errors.

None of these are negatively-skewed distributions. In particular, the chi-squared distribution always has non-negative skew for any value of parameters (it's not the only one, just an obvious one).

The only negatively-skewed distribution we could think of off the top of our head --the Beta distribution with appropriate parameters -- didn't even make the list.

How is this more useful than, say, asking on the Statistics Stack Overflow (or searching to see if someone has already asked)?

Someone with a certain amount of statistical background can skim this list and realize that at least some of the answers are clearly wrong. They are then reduced to checking the whole list--which they already could have done with a list of distributions and Wikipedia. And they would have found the Beta distribution quicker from Wikipedia, too.

Someone with less of a statistical background and not a lot of time might just take the answers as correct, and go on to use them (wrongly!), no matter how many disclaimers OpenAI puts on their interface. And therein lies the problem.

LLMs are Great for Remembering Things You Know #

There are two uses for which I find ChatGPT incredibly useful: looking up the answers to simple code questions, and as an intelligent thesaurus.

An example of the first: How do I parse an RSS feed in Python? ChatGPT gives me the appropriate library (feedparser) and some example code. I can easily check if the example code does what I want, and with the name of the library, I can look up the actual documentation.

It used to be easy to find this sort of information via search, but now the results are so poisoned by paywalls and splogs that it's far simpler, and more pleasant, to ask ChatGPT. Unlike with clicking on random search results, ChatGPT's answers are usually accurate the first time.

An example of the second: What's the word for a close-up from a painting? It's used in the context of art or art history. The answer is detail, as in "A detail from The Last Supper, showing Judas clutching a bag of coins," to describe an image of Judas Iscariot cropped from The Last Supper. This is a word I try to use in appropriate situations (like crediting images on my blog) but I can never remember it.

ChatGPT tends to be better at these kind of "What's that word for...?" questions than standard search, or even than my husband, if he happens to be around (he's not bad at it, just ChatGPT is better).

Here's the thing though: I already knew the word, I just couldn't remember it. And I already know Python, just not all of its libraries. I can recognize when I'm getting correct information, and, in these two situations, I can get it quickly. That's great!

Caveat User #

My other big use for LLMs is translation. DeepL and the AI translator/explainer at Tagalog.com are super useful for my hobbies of translating Spanish-language short stories and Filipino comics, respectively -- Spanish and Filipino being languages I can at least somewhat read. And DeepL and Google Translate are helpful when trying to get the gist of a document in a language I don't read.

But here's the thing; I've seen these translation engines (even DeepL, which is generally quite good) make some egregious mistakes. I also remember trying to use the AI explainer at Tagalog.com to help me disentangle some sentence where I was getting all mixed up with the tenses and object and subjects. I think it got the grammar correct, but, boy, it just outright lied to me about the meaning of the word bubuwit, which means mouse. I ran the sentence through the explainer multiple times, and got told that bubuwit means, variously, fish, worm, lizard ... I lost confidence, and checked several dictionaries to make sure: yes, bubuwit means mouse.

The lesson: don't entirely trust the machine translations of languages you don't read. Which I think we already knew, Google Translate having been around for a long time.

Similarly: don't entirely trust the code snippets from ChatGPT (or Copilot, I imagine) for programming languages that you don't know. Copilot and ChatGPT won't instantly make me a competent Rust programmer, any more than DeepL will make me a competent literary translator of Hungarian. This should also be obvious, but with all the genAI hype, I'm not sure it is.

Because if I can find glaring errors in areas where I have some expertise, why should I be confident that there aren't glaring errors in areas I know nothing about?

Information Literacy #

I have seen people make the argument: yeah, ChatGPT can spit out bullshit, but why should I trust it less than some random dude on the internet? They spit out bullshit, too. Yes, that's an issue, and it's called information literacy. Information literacy means the ability to assess the information you're given, via your own personal competencies, and your ability to recognize the legitimacy and reliability of the sources of the information. It also means consulting multiple sources, when possible.

But how do you do that, with a monolithic information channel that obscures its sources? Not to mention, just mashes them all up and spits out a plausible sounding response that, in some sense, doesn't even have a source? All you can rely on, then, is your own personal competencies. Again: don't ask questions you don't already know the answer to, or can't vet from your own knowledge.

It's back to my mantra. Avoid magic; value understanding. Or as Anil Dash might put it: Avoid magic; value reason.

Generative AI can be a great tool, but like any tool, you have to use it the right way.

Clarity, Not Magic

2024-02-21T00:00:00Z

After migrating this blog to Eleventy, I made the comment on Micro.blog that Eleventy "is so much easier to wrap my arms around" than Jekyll was. That got me to wondering--why is that?

After some thought, I came up with a few reasons:

Newbie-friendly design and documentation that makes the process less opaque.
Starter code that is simple to read, but that still illustrates useful functionality
A blog deployment process that is manual, but not mystical.

That last point is the crux, for me. After all, the reason I migrated my site was because the old one broke, and I didn't know how to fix it. I won't lie. The way the old site got automatically built and deployed on Github Pages was mysterious to me. I found a Jekyll template I wanted, and followed some directions that seemed to work, and Voila! To me, setting up that first website was not that far removed from following some arcane ritual.

And it worked, until it didn't. I knew that something, somewhere was going out of date and needed to be updated, but I didn't know what, or how. And so I had to start from scratch.

And this time, no magic incantations.

So, this post will expand upon the points above, but it's really not about my adventures with Eleventy. It's meant to be a concrete exploration of some general principles about how to design a process; how to teach (or document) a process; and the difference between informed, purposeful action versus blindly following ritual.

Read on.

Illustration of Goethe's Der Zauberlehrling (The Sorcerer's Apprentice), 1882.
Artist: Ferdinand Barth. Source: Wikimedia

Newbie-Friendly, Non-Opaque Design #

The default way of putting a blog on Github Pages involves some mysterious (to me) interaction of Gemfiles and Github Actions and automated processes that are hidden from the user. I try reading the documentation, but it's written assuming some background context/knowledge that I don't have. I can make it work--I've put up at least three Jekyll blogs, starting from other people's templates--but I've never really understood the workings of the process. And every time I want to put up a blog, I have to look up how to do it.

The Eleventy "Get Started" page is so newbie-friendly that it even has a link to a page that explains terminal windows. It walked me through installing Node.js, and the commands that I need to install Eleventy, build a rudimentary website, and serve it (locally). Now, I don't know anything about Node.js or JavaScript, but by walking through the tutorial and looking at the artifacts produced: the package.json, the node_modules directory, and so on -- I gained some intuition about how the process works.

Because I feel like I understand what's going on, I can write down the steps in a way that makes sense to me, and repeat it -- purposefully, not blindly. In other words, there is something about the design of the software and its starter documentation that elucidates the process, making it easier to follow.

Incidentally, the "Get Started" page even shows you how to deploy the baby website, via Netlify. It looked pretty easy, and if I were starting brand-new, I probably would have gone that route. But I'm already on Github Pages, so I decided to stick with that. I was a little nervous about this choice, but it turned out quite well---more on that later.

Most of the Eleventy documentation still goes over my head, but I'm not worried about that, because I had ...

A Simple but Functional Starter Example #

This is an extension of the "Newbie-friendly design" principle. The first time I stood up my site, I knew nothing about "website stuff" except some rudimentary HTML. I needed code examples, to help teach me about CSS, and Liquid, and so on. The built-in Github Pages Jekyll themes were too simple to help me understand how to build the structure of a blog. The theme I ended up using made a nice site, but it was really too complex to be an effective learning instrument. So it, too, for a long time, was mostly just magic.

Eleventy's base blog starter template has enough functionality to be useful, a clear and simple design, good file organization, and low dependencies: HTML/markdown, CSS, Nunjucks, minimal Javascript. By looking at the code, and by peeking into the package.json and the node_modules directory that got generated when I installed the template, I could figure out how things work. I can't build a theme from scratch, but I can figure out how to modify this one. A little at a time.

It's not magic, and eventually, I assume, more of the documentation will make sense. If I need it to.

My new site is still missing a few things I had before, but it's not bad-looking, if I do say so myself.

Non-Mystical Deployment #

This was the step that made me nervous. Jekyll is the default build process for Github Pages sites. How was a non-Jekyll build going to work? Would I be able to do it?

The official answer is Github Actions, and someone did write an Action for deploying Eleventy sites. But guess what: I don't understand Github Actions. This felt like bringing more magic into the workflow, and if that Action ever broke---I'd be stuck, again.

So I looked around, and figured out that I could build and deploy the site manually, with the help of this package. It's far less convenient than having the site just rebuild when I push changes to the source, but I know what it's doing. And my site isn't going to change that frequently, anyway. Under the circumstances, a manual process I understand is preferable to an automation that I don't understand, and don't really need. Someday, my assessment of the tradeoffs may change; and then my mind will change, too.

Right now, it works like a charm.

But Nina, why is a Github Action magic, but a package you found on the internet not magic?

Yeah, I suppose it's magic, too, but it's magic that works over Git, not Github. I suspect git is somewhat more stable than any given Github feature. Also, I understand git. So I'd call the package "less magic" than an Action. To me, that is; if you are comfortable with Github Actions, then none of this is magic at all. Go crazy.

So, What Have We Learned? #

Out of all this, I can try to articulate some general principles, in no particular order.

Avoid magic. If you do X by blindly following a list of steps you don't understand, you don't know how to do X. You're just following a ritual. And rituals can fail.

By the above definition, magic is relative.

A well-designed process is complex enough to be useful, but simple and clear enough to be learnable.

A good teaching example (code, documentation) should also be complex enough to be useful, but simple and clear enough to be learnable.

Try to be newbie-friendly. If you can write or design for a user who knows absolutely nothing at the start, but will have something by the end, someone out there will thank you for it.

Prefer understanding a process ("no magic") to streamlining it (opaque automations might be magic).

Blog Migration

2024-02-19T00:00:00Z

My jekyll-generated website (served by Github Pages) failed to build a couple of weeks ago; I don't know why. I'm not enough of a front-end developer to diagnose the problem. After looking around for an updated template to move to, I eventually decided to give the Eleventy static site generator a try.

So this is my new site, based on Eleventy's official starter blog template. It wasn't too hard to figure out, and deployed surprisingly easily! Best of all, Eleventy is built to be stable; which hopefully means I won't run into that my website won't build, and I don't know why! problem again.⊕ It's also designed to build really fast, but that matters less to me. Hurray!

A better developer than I am probably could have migrated the old jekyll site completely, but I didn't manage to do that. I've only carried a few blog posts and pages over for the moment. I'll put a few more of the old posts back, and my publications page; eventually I'll figure out how to get my bookshelf and my talks pages back up, too. But at least there's something here, for now.

Fun With Chat GPT

2024-01-29T00:00:00Z

So, my husband typed this into ChatGPT 3.5:

What are some English words that are 4 letters long, start with f, and end with k?

According to ChatGPT, there was only one word that fit that criterion: fork. Upon prodding, it admitted that there were maybe a few more:

Typing a similar query into DuckDuckGo (4 letter word starting with f ending with k) produced a page full of links to various crossword puzzle and Scrabble dictionaries. The first link gave me seven words. A little further down, I found a link that gave me thirteen words: faik, fank, feck, filk, fink, firk, fisk, flak, folk, fork, funk, fusk, and of course, "the F-word."

I'm sure that ChatGPT has filters to eliminate profanity, and admittedly, not all the above words are "common," but, come on -- folk? funk? flak?? I particularly like feck, though I never hear of anyone being "full of feck," only "feckless" ...

I'm sure GPT-4 does better, but I don't care to pay to find out.

The Sphering Transform for Detecting Distribution Drift

2023-08-21T00:00:00Z

I have a new blog post up on the Win Vector blog: Detecting Data Differences Using the Sphering Transform.

In this post, I discuss how to convert the problem of detecting changes in multivariate distributions to the simpler problem of detecting changes in univariate distributions. Please check it out.

Pandas-Polars Rosetta Stone

2023-04-10T00:00:00Z

Just created a handy little Rosetta stone of common data operations using both the pandas and polars libraries. Maybe you'll find it useful, too.

The What, Why, and How of AB Testing

2023-04-07T00:00:00Z

This article is a shortened version of a post from the Wallaroo Blog, originally written by Julio Barros and me. I'm posting the non-Wallaroo section of that article here, with permission, because I think it's a useful reference for A/B testing---one that I refer to myself. Hopefully, others find it helpful as well.

How to A/B Test Machine Learning Models #

A/B tests are a key tool of business decision-making. In this article, we'll discuss the what and why of A/B testing, and how an A/B test is designed.

What is an A/B Test? #

An A/B test, also called a controlled experiment or a randomized control trial, is a statistical method of determining which of a set of variants is the best. A/B tests allow organizations and policy-makers to make smarter, data-driven decisions that are less dependent on guesswork.

In the simplest version of an A/B test, subjects are randomly assigned to either the control group (group A) or the treatment group (group B). Subjects in the treatment group receive the treatment (such as a new medicine, a special offer, or a new web page design) while the control group proceeds as normal without the treatment. Data is then collected on the outcomes and used to study the effects of the treatment.

Author: Seobility - License: [CC BY-SA 4.0]( "Creative Commons License BY-SA 4.0")

A/B Testing in History #

This idea has been around for a long time. Historically, farmers have divided their fields into sections to test whether various treatments can improve their crop yield. Something like an A/B nutrition test even appears in the Old Testament!

“Please test your servants for ten days. Let us be given vegetables to eat and water to drink. You can then compare our appearance with the appearance of the young men who eat the royal rations…" (Daniel 1:12-13)

In 1747, Dr. James Lind conducted one of the earliest clinical trials, testing the efficacy of citrus fruit for curing scurvy.

A/B Testing Today #

Today, A/B tests are an important business tool, used to make decisions in areas like product pricing, website design, marketing campaign design, and brand messaging. A/B testing lets organizations quickly experiment and iterate in order to continually improve their business.

In data science, A/B tests can also be used to choose between two models in production, by measuring which model performs better in the real world. In this formulation, the control is often an existing model that is currently in production, sometimes called the champion. The treatment is a new model being considered to replace the old one. This new model is sometimes called the challenger. In our discussion, we'll use the terms champion and challenger, rather than control and treatment.

Keep in mind that in machine learning, the terms experiments and trials also often refer to the process of finding a training configuration that works best for the problem at hand (this is sometimes called hyperparameter optimization). In this article, we will use the term experiment to refer to the use of A/B tests to compare the performance of different models in production.

How to Design an A/B Test #

A/B tests are a useful way to rely less on opinions and intuition and to be more data-driven in decision making, but there are a few principles to keep in mind. The experimenter has to decide on a number of things.

First, decide what you are trying to measure. We'll call this the Overall Evaluation Criterion or OEC. This may be different and more business-focused than the loss function used while training the models, but it must be something you can measure. Common examples are revenue, click-thru rate, conversion rate, or process completion rate.

Second, decide how much better is "better". You might want to just say "Success is when the challenger is better than the champion," but that's actually not a testable question, at least not in the statistical sense. You have to decide how much better the challenger has to be. Let's define two quantities:

y0: The champion's assumed OEC. Since the champion has been running for a while, we should have a good idea of this value. For example, if we are measuring conversion rate, then we might already know that the champion typically achieves a conversion rate of y0 = 2%.
𝞭: the minimum delta effect size we want to reliably detect. This is how much better the challenger needs to be for us to declare it "the winner." For example, we may decide to switch to our challenger model if it improves the conversion rate by at least 1% – that is, we want the challenger to have a conversion rate of at least 0.02 * (1.01) = 0.0202. This means 𝞭 = 0.002.

Note that some sample size calculators (we'll get to that below) specify minimum effect size as a relative delta; in our example, the relative delta is 0.01 (1%), and the absolute delta is 0.002.

Third, decide how much error you want to tolerate. Again, you probably want to say "none," but that isn't practical. The less error you can tolerate, the more data you need, and in an online setting, the longer you have to run the test. In the classical statistics formulation, an A/B test has the following parameters to describe the error:

𝞪: the significance, or false positive rate that we are willing to tolerate. Ideally, we want 𝞪 as small as possible; in practice, 𝞪 is usually set to 0.05. You can think of this as meaning that if we run an A/B test over and over again, we will incorrectly pick an inferior challenger 5% of the time.
𝞫: the power, or true positive rate we want to achieve. Ideally, we would like 𝞫 near 1; in practice, 𝞫 is usually set to 0.8. You can think of this as meaning that if we run an A/B test over and over again we will correctly pick a superior challenger 80% of the time.

Note that 𝞪 and 𝞫 are talking about incompatible circumstances (that's why they don't add up to 1). The first case assumes the challenger is worse, the other case assumes it's better; finding out which situation we are in is the whole point of an A/B test.

There's one last parameter in an A/B test:

n: the minimum number of examples (per model) we have to examine to make sure our false positive rate 𝞪 and true positive rate 𝞫 thresholds are met. Or as it's commonly said: "to make sure we achieve statistical significance."

Note that n is per model: so if you are routing your customers between A and B with a 50-50 split, you need a total experiment size of 2n customers. If you are routing 90% of your traffic to A and 10% to B, then B has to see at least n customers (and A will then see around 9n). So a 50-50 split is the most efficient, although you may prefer an unbalanced split for other reasons, like safety or stability.

To run an A/B test, the experimenter picks 𝞪, 𝞫, and the minimum effect size 𝞭, and then determines n. We won't go into the formula for calculating n here; so-called power calculators or sample-size calculators exist to do that for you. Here's one for rates, from Statsig; it defaults to 𝞪 = 0.05, 𝞫 = 0.8, and split ratio of 50-50. Feel free to play around to get a sense of how big sample sizes have to be in different situations.

Once you've run the A/B test long enough to achieve the necessary n, measure the OEC for each model. If OECchallenger - OECchampion > 𝞭, then the challenger wins! Otherwise, you may wish to stick with the champion model.

Some Practical Considerations #

Splitting your subjects: When splitting your subjects up randomly between models, make sure the process is truly random, and think through any interference between the two groups. Do they communicate or influence each other in some way? Does the randomization method cause an unintended bias? Any bias in group assignments can invalidate the results. Also, make sure the assignment is consistent so that each subject always gets the same treatment. For example, a specific customer should not get different prices every time they reload the pricing page.

A/A Tests: It can be a good idea to run an A/A test, where both groups are control or treatment groups. This can help surface unintentional biases or errors in the processing and can give a better feeling for how random variations can affect intermediate results.

Don't Peek!: Due to human nature, it's difficult not to peek at the results early and draw conclusions or stop the experiment before the minimum sample size is reached. Resist the temptation. Sometimes the "wrong" model can get lucky for a while. You want to run a test long enough to be confident that the behavior you see is really representative and not just a weird fluke.

The more sensitive a test is, the longer it will take: The resolution of an A/B test (how small a delta effect size you can detect) increases as the square of the samples. In other words, if you want to halve the delta effect size you can detect, you have to quadruple your sample size.

Extensions to A/B Testing #

Bayesian A/B Tests

The classical (AKA frequentist) statistical approach to A/B testing that we described above can be a bit unintuitive for some people. In particular, note that the definitions of 𝞪 and 𝞫 posit that we run the A/B test over and over; in actuality, we generally run it only once (for a specific A and B). The Bayesian approach takes the data from a single run as a given, and asks, "What OEC values are consistent with what I've observed?"

The general steps for a Bayesian analysis are roughly:

Specify prior beliefs about possible values of the OEC for the experiment groups. An example prior might be that conversion rates for both groups are different and both between 0 and 10%.
Define a statistical model using a Bayesian analysis tool (ie. using distributional techniques) and flat, uninformative, or equal priors for each group.
Collect data and update the beliefs on possible values for the OEC parameters as you go. The distributions of possible OEC parameters start out encompassing a wide range of possible values, and as the experiment continues the distributions tend to narrow and separate (if there is a difference).
Continue the experiment as long as it seems valuable to refine the estimates of the OEC. From the posterior distributions of the effect sizes, it is possible to estimate the delta effect size.

Posterior distributions of a Bayesian treatment/control test. Source: Win-Vector Blog

Note that a Bayesian approach to A/B testing does not necessarily make the test any shorter; it simply makes quantifying the uncertainties in the experiment more straightforward, and arguably more intuitive. For a worked example of frequentist and Bayesian approaches to treatment/control experiments (in the context of clinical trials), see this blog post from Win Vector LLC.

Multi-Armed Bandits #

If you want to minimize the waiting until the end of an experiment before taking action, consider Multi-Armed Bandit approaches. Multi-armed bandits dynamically adjust the percentage of new requests that go to each option, based on that option's past performance. Essentially, the better performing a model is, the more traffic it gets—but some small amount of traffic still goes to poorly performing models, so the experiment can still collect information about them. This balances the trade-off between exploitation (extracting maximal value by using models that appear to be the best) and exploration (collecting information about other models, in case they turn out to be better than they currently appear). If a multi-armed bandit experiment is run long enough, it will eventually converge to the best model, if one exists.

Multi-armed bandit tests can be useful if you can't run a test long enough to achieve statistical significance; ironically, this situation often occurs when the delta effect size is small, so even if you pick the wrong model, you don't lose much. In fact, the exploitation-exploration tradeoff means that you potentially gain more value during the experiment than you would have running a standard A/B test.

New Article on the XI coefficient

2021-12-30T00:00:00Z

I have a new article up on the Win-Vector blog, about the ξ ('XI') correlation coeffient that was recently introduced by Professor Sourav Chatterjee in his paper, “A New Coefficient of Correlation”.

Unlike traditional correlation coefficients, ξ does not assume that the relationship between x and y is linear; in principle, it can be any functional relationship. While this is potentially useful, ξ also has some disadvantages, too.

In my Win-Vector post, I run some informal experiments to try to get a sense of what different values of ξ might mean.

Please check it out.

Design, Problem Solving, and Good Taste

2014-11-25T00:00:00Z

I ran across this essay recently on the role of design standards for scientific data visualization. The author, Jure Triglav, draws his inspiration from the creation and continued use of the NYCTA Graphics Standards, which were instituted in the late 1960s to unify the signage for the New York City subway system.

Image: A Case for Spaceships (Jure Triglav)

As the author puts it, the Graphics Standards Manual is "a timeless example of great design elegantly solving a real problem." Thanks to the unified iconography, a traveler on the New York subway knows exactly what to look for to navigate the subway system, no matter which station they may be in. And the iconography is beautiful, too.

Unimark, the design company that designed the Graphics Standards.
Aren't they a hip, mod looking group? And I'm jealous of those lab coats.
Image: A Case for Spaceships (Jure Triglav)

What works to clarify subway travel will work to clarify the morass of graphs and charts that pass for scientific visualization, Triglav argues. And we should start with the work of the Joint Committee on Standards for Graphical Presentation, a group of statisticians, engineers, scientists, and mathematicians who first adopted a set of standards in 1914, revised in 1936, 1938, and 1960.

I agree with him -- mostly.

The 1914 and 1938 reports are online; if you have read William Cleveland's The Elements of Graphing Data or Darrell Huff's How to Lie with Statistics, you will have seen most of the guidelines before, although I thought the 1938 report in particular was especially clear and eloquent about its guiding principles. It should be noted that the 1938 document emphasizes that the guidelines are only that -- they are not intended as a set of rigid rules.

The committee believes that effective presentation calls for flexibility of treatment rather than for standardization, that each chart should be individually planned with due reference to the special characteristics of the data and the particular use to which the chart is to be put.

And in fact, while Cleveland and Huff definitely both echo the Joint Committee's recommendations, they do disagree in places, for example on whether or not a graph of quantities should always include zero. It depends on the use of the chart: exploration vs. presentation. The NYCMTA Graphics Standards address a specific situation; in this case, fixed, rigid standards are appropriate. When we are discussing all of scientific and engineering visualization, the best we can hope for are a set of guiding principles. What the Joint Committee -- and Cleveland, Huff, Tufte, and others -- were really trying to do is to set the standards for good taste.

People think of taste as a subjective thing, and when it comes to food, fashion, film, art, or literature, that's true. One person's great read is another person's awful junk. I avoid accusing anyone of having "bad taste" when it comes to the subjects above. But in the problem solving disciplines - computer science (coding in particular), engineering, architecture, ergonomics, math, science, and so on - I think that bad taste is a real thing. A real harmful thing. We already use terms like "elegant" or "ugly" when we describe mathematical proofs, or code, or other solutions to various problems. Some "solutions" can be so ugly that they are in fact counterproductive. That's bad taste.

Let's go back to our mass transit example with this critique from user experience designer Sarah Doody on the badly designed ticket machines (that were in place at the time of her visit) for BART, San Francisco's subway/light-rail system. And in her criticism, she didn't even get to what I'd noticed was the biggest problem for new users: where the purchased ticket came out was nowhere near either the screen or the slot where you entered money; it came out well below eye level (in the red region of the left image, below). Compare that with the MTA's ticket machines, where the ticket dispensers are right next to the money insertion slot:

Left image: Nile Guide; Right image: Rev Stan, Flickr

To my mind, the old BART ticket machine is the equivalent of spaghetti code: technically, it gets the job done, but it's ugly, incomprehensible, and as Ms. Doody points out, many of the choices that went into its creation are just plain wrong. Its design, such as it was, could be fairly called bad taste. Some people see it the other way:

What we are trying to point out is: design is not always just a matter of taste. With enough design principles in mind (such as least astonishment, Liskov substitution, and a few others) you can actually say some design decisions are wrong (and maybe even some day some other design decisions are right). There are very few general principals of software system design, so you really don’t want to ignore the few you have.

-- John Mount, Factors are not First-class Citizens in R

I would argue that design is a matter of taste. It's just that, in the problem-solving disciplines, taste is not entirely subjective.

What's Wrong with a Low(er)-Stress Job?

2013-01-05T00:00:00Z

So there's this article that's been making the rounds called "The 10 Least Stressful Jobs of 2013"; perhaps you've read it. I don't normally bother with articles like that, but it came to my attention because some of my old graduate-school friends (who are professors) threw a mini-rant on social media over the fact that University Professor is the Number One least stressful job of the year, according to the article. And just now, I tripped over a blog post where a librarian takes umbrage over the fact that they also on the list.

Curiosity led me to finally skim the article in question. I won't lie, I think some of their choices are odd, and the reasoning that led to those choices is rather simplistic. But I'm not going to quibble with the article itself; frankly, I don't really care (you notice I only said "skim," not "read"). What I find interesting is that people are actually offended at being on that list.

Think about some jobs that are truly high-stress. Firefighter. Police Officer. Emergency Medical Technician. A case worker for Child Protective Services (especially with budgets the way they are now). Pediatric Oncologist. Heck, what about being unemployed? Seems pretty darned stressful to me.

A lot of high-stress occupations aren't well compensated, and many aren't particularly glamorous. I doubt that people in those professions thought to themselves, "Let's see, what's the most stressful job I can think of? I'll go do that." I think they do those jobs in spite of the stress, because of innate vocation, or passion, or the desire to make the world a better place, or whatever. If you could magically make the stress of their jobs disappear, I don't think they'd complain.

The problem is that "high-stress job" is often used as code for "challenging job for hard-working, driven people" -- which makes "low-stress job" code for "easy job for lazy people." Really, they aren't the same thing. Hard work is a virtue; stress is a disease. A disease is something you should try to alleviate, not celebrate.

Obviously, some jobs (like firefighter and police officer) are innately stressful, because they are dangerous, or because you always work in emergency conditions. And a little stress is good for you, in the sense that stress is what pumps up your adrenaline to meet an immediate challenge, or that some level of difficulty in your job is what keeps it interesting, and what keeps you engaged. But if you aren't throwing yourself in the way of bullets or into towering infernos on a regular basis, perhaps you might think about how to separate the necessary hard work from the unnecessary demands on your energy.

You know, like planning ahead and pacing yourself so you don't get caught unawares by deadlines. Saying "no" to more work when you are already overbooked. Trying not to get overbooked in the first place, to the extent you can avoid it. Figuring out how to sidestep tasks or situations or people that cause you stress or sap your energy. Or at least minimize the time you spend on such energy-drains.

Those things aren't possible one hundred percent of the time, and they are more possible in some job situations than others. If you are in a job situation where it is possible, why be ashamed of that? Take advantage of it.

Or to put it another way: job-stress often comes from having no control over your situation, or at least the perception of having no control.

Is that really how you want your career to define you -- as someone controlled by the job, not vice-versa? Or would you rather be someone who works to meet all your goals and make your mark on the world on your own terms?

I want to think of myself the second way. And if that means that people call my job "low-stress" -- even in a snarky way -- that's fine. Part of being in control is not caring about the opinions of people who are obviously wrong.

Think about it.

On Balance

2012-12-18T00:00:00Z

One of my favorite cheesy movies is a gem from 1984 called The Adventures of Buckaroo Banzai Across the 8th Dimension. For those who haven't seen it, Buckaroo Banzai is a brilliant young neurosurgeon and particle physicist who spends his days conducting cutting-edge research. At night, he and his research colleagues -- all engineers and scientists and doctors -- rock New Jersey as a band called the Hong Kong Cavaliers. In between the brilliant science and the rock-star night life, the Cavaliers find time to save the world from an alien invasion led by none other than John Lithgow.

It's very eighties: full of funky jackets with padded shoulders and some crazy hair. I can't recommend it enough.

What happens if you want to be Buckaroo Banzai in real life? Here's what biologist Adam Ruben writes in his article "The Myth of the Well-Rounded Scientist:"

Scientists with outside interests are often regarded with suspicion in the lab; we can be seen as undedicated, unfocused, easily distracted, and so divorced from the scientific frame of mind that we’ll probably end up working in—oh, the shame—industry.

Ruben started his "Batman job," as he calls it -- stand-up comedy -- in grad school, and it was in grad school where he learned to hide his extracurricular activity.

One day, my adviser called me into his office. The campus newspaper had just published a little profile of the stand-up-comedy-performing grad student, and my adviser happened to read it. Over the next 10 minutes, I learned that my hobby was an embarrassment to the department, that there was no way I could properly focus on biology, and that every negative lab result I ever produced was a direct result of telling jokes at night.

For a moment, I even believed it was true. …

It's not true, of course. Very few people truly want to spend every waking hour in the lab (or office) and, frankly, no one should. And if you're not in the lab or the office, why shouldn't you be standing onstage somewhere, performing?

It's a variation on the problem that professional women with children have faced for years: the so-called "work/life balance" issue. I've always hated that phrase. It implies that if you have a "life" -- children, family, other creative interests, what have you -- then by definition, your work isn't part of your life. And so it follows that you aren't as "dedicated" or "passionate" about your work as you ought to be.

And that's nonsense. I, too, have a "Batman job": I dance. I have rehearsal three to four times a week, and a performance at least once a month -- sometimes more. I love my Batman job. And I love my day job, too. Being a data scientist is a part of my life, just as much as being a dancer, a wife, a daughter, and a blogger are all parts of my life.

It's not "work/life balance" -- it's "life balance." For some people, that balance honestly means spending 99.5% of their waking hours eating, breathing, and dreaming about data science or biology or math or marketing strategy. For others, like me, balance means spending 50% of my time (or whatever 40 hours a week -- sometimes a little more, not much less -- comes to) thinking about data science, and 50% of my time thinking about other things.

It also means that for that 50% of my time that I spend on data science, I concentrate on data science: my clients' projects, my data science writing, or my data science reading. Having other interests is an advantage here. I am forced to be efficient with the hours I spend on my day job, because no matter what (except for a dire emergency), at 7:30 pm I have to get up and go to rehearsal. I can't make up for lazy days with long nights in front of the computer.

The break probably does my brain good, too. The mathematician Jacques Hadamard, in his book The Psychology of Invention in the Mathematical Field, wrote about what he and Henri Poincaré called "incubation": the process of letting go of conscious thought about a difficult problem and allowing your unconscious mind to work on it instead. Incubation leads to breakthrough. Here, Hadamard quotes Poincaré:

"When, as must often happen, the thinker makes a false start, he slides insensibly into a groove and may not be able to escape at the moment. … Incubation would consist in getting rid of false leads and hampering assumptions so as to approach the problem with an 'open mind.'" We can call this the forgetting-hypothesis.

In other words, when you are stuck on something, stop working and literally forget about it; think about something else. What better way to get your mind out of its rut than to go out and dance, or work on your stand-up comedy routine, or play with your kids? My husband, who is a dedicated computer scientist and mathematician, tells of similar experience. He recently started to teach himself to draw, and tries to spend a at least an hour a day working on sketching exercises. As with any exercise or drill, this can sometimes begin to feel tedious. The way my husband tells it, his brain is so desperate to break out of the tedium that it will of its own volition start chewing on whatever difficult problem has presented itself in his work life. By the time he is done with his exercises, he often has a new breakthrough, and can sit at the computer to attack his sticky problem with a fresh mental outlook.

Being a 50% data scientist instead of a 99% data scientist doesn't mean I don't enjoy what I do for a living. It doesn't mean I'm not good at it. It doesn't mean that I take my responsibilities to clients and peers any less seriously than a 99 percenter. It does mean that I have chosen to give up certain achievements that likely come only with a eat-breathe-dream lifestyle. I will never win a Nobel or a Fulkerson Prize. I will never be a world-famous thought leader on data science (or anything else). I will never hold a Cabinet position. I will never run a multimillion-dollar corporation, or be a senior executive at such a corporation. I will never be as rich as Bill Gates or Sergey Brin.

And that's okay. As long as I have a good professional reputation, as long as my peers and clients respect me and respect my work, I'm satisfied. Just don't mistake my lack of ambition for certain measures of success as a lack of dedication to my field -- or a lack of competence.

I Write, Therefore I Think

2012-10-11T00:00:00Z

I came across an interesting article in The Atlantic a little while back that discussed the connection between writing and thinking. New Dorp, a Staten Island high school in a poor and working-class neighborhood, was able to improve student performance when they realized that their students couldn’t write. These underperforming students often could read and could do math. The majority of them were well-behaved, and seemed to want to learn. Yet they couldn't pass standard proficiency tests, and couldn't graduate. All because they couldn't form complex sentences.

The harder they looked, the teachers began to realize, the harder it was to determine whether the students were smart or not because the tools they had to express their thoughts were so limited that such a judgment was nearly impossible.

Photo: Nina Zumel

The solution the teachers devised was to teach analytical writing skills in almost every class. For example, in chemistry classes, students had to describe the properties of chemical substances in sentences that used specific subordinate clause forms, such as a sentence with although, or with unless. Students in literature classes had to hold oral discussions using structured sentence forms: "I (dis)agree with your statement because...", "Can you explain your answer?" They had to write expository essays in history class.

The result? Graduation rates have risen from 63% to almost 80% since the beginning of the program. Pass rates on proficiency tests rose from 67% to 89% for the English exam, and 64% to to 75% for the History exam. There's still room for improvement, but the outlook at New Dorp is optimistic.

Reading the Atlantic article, I got the suggestion that knowing how to form sentences and how to express themselves strengthened the students' ability not only to write and to pass tests, but also actually strengthened their ability to think. Once you know that there exist words and phrases like because or for instance that help expand your sentences, to elaborate on your basic premises, then you will want to start using them, right? It's like turning on a faucet.

This apparently causal relationship between writing and thinking is no surprise for anyone who has to write as part of making a living. I find that I often don't truly understand a technical topic until I sit down to write about it. And some of my best non-technical writing happens when I have no fixed notion of what I'm going to say, just a vague idea that I must write about some topic, or that I must expand on some passing thought I had over a cup of coffee. The end result of the article or blog post surprises even me. Usually pleasantly, even.

Here's Joan Didion, from her wonderful essay "Why I Write":

Had I been blessed with even limited access to my own mind there would have been no reason to write. I write entirely to find out what I'm thinking, what I'm looking at, what I see and what it means. What I want and what I fear. ... What is going on in these pictures in my mind?

And here's George Orwell, on why jargon is evil (from the essay "Politics and the English Language"):

A man may take to drink because he feels himself to be a failure, and then fail all the more completely because he drinks. It is rather the same thing that is happening to the English language. It becomes ugly and inaccurate because our thoughts are foolish, but the slovenliness of our language makes it easier for us to have foolish thoughts. The point is that the process is reversible. Modern English, especially written English, is full of bad habits which spread by imitation and which can be avoided if one is willing to take the necessary trouble. If one gets rid of these habits one can think more clearly, and to think clearly is a necessary first step toward political regeneration: so that the fight against bad English is not frivolous and is not the exclusive concern of professional writers.

Orwell is talking about how words like "freedom," "terrorist," or "socialist" gradually lose their true meaning after years of overuse and mis-use, until they become content-free. Dialogue or debate that uses such words therefore also becomes content-free, and we all spend a lot of words saying nothing. When we say nothing, we think nothing: a vicious cycle. Places like New Dorp give us hope that words can feed a virtuous cycle, as well. Words have power.

On the other hand, the New Dorp approach is rather formula-oriented, isn't it? It's old-fashioned, redolent of the old classic high school expository essay form. Remember that? State your thesis. Support it in the body of the essay; each body paragraph has a topic sentence and evidential support. Conclude by restating your thesis and re-examining it in the light of your evidence. The format is clear, and when done properly, it's an efficient way to get a point across. It's also usually quite dry.

There are people who think old-fashioned is a good thing; back to the basics, and all that. There are people who don't. As some civil-rights activist supposedly once said (sorry, I don't remember who): "I am suspicious of people who are nostalgic." With reason: the "good old days" were often not so good, for many different groups of people. In our discussion, that would be the disengaged student.

So the modern teaching approach, apparently, encourages the student to develop self-expression, in the name of keeping them engaged, and fostering creativity. Sentence structure and the craft of organizing your thoughts don't seem to be primary lesson goals. So the Atlantic article claims; I'm not a teacher, and I don't have school-age children, so I don't really know. But if it's true, it's interesting, because some people would claim that the art of creative writing is the antithesis of thinking. Here's Robert Olen Butler, from his book From Where You Dream: The Process of Writing Fiction:

Please get out of the habit of saying that you've got an idea for a short story. Art does not come from ideas. Art does not come from the mind. Art comes from the place where you dream. Art comes from your unconscious; it comes from the white-hot center of you. ... If you want to think your way into your fiction, if you think you can analyze your way into a work of art, we're going to be totally at odds philosophically about what art is and where it comes from.

The truth, as always, is probably somewhere in between, but the point is that by Butler's argument, teaching creative writing is not teaching children how to think (it might even be teaching them not to think). And isn't the point of school to teach children how to think? That's what they keep telling us. It's interesting to contrast this with some current discussion about teaching math in schools, for example Andrew Hacker's now-infamous opinion piece from a few months ago, "Is Algebra Necessary?" According to Hacker, algebra is not a life skill; most people won't ever use it again. Putting aside whether that's true (it's not), a similar argument, it seems to me, could be made about creative writing. Why is algebra bad for being allegedly impractical, while analytical writing is bad for being merely practical?

I wouldn't want the pinnacle of my literary achievement to be the high school expository essay, and I do wish I had taken more classes in creative writing during my formal education. The world would be a bland place if it were merely practical. But if writing well begets thinking well, then it transcends the practical: it's essential. And what else should we be teaching in schools, if not the essential?

On Being a Data Scientist

2012-09-19T00:00:00Z

When people ask me what it means to be a data scientist, I used to answer, "it means you don't have to hold my hand." By which I meant that as a data scientist (a consulting data scientist), I can handle the data collection, the data cleaning and wrangling, the analysis, and the final presentation of results (both technical and for the business audience) with a minimal amount of assistance from my clients or their people. Not no assistance, of course, but little enough that I'm not interfering too much with their day-to-day job.

This used to be a key selling point, because people with all the necessary skills used to be relatively rare. This is less true now; data science is a hot new career track. Training courses and academic tracks are popping up all over the place. So there is the question: what should such courses teach? Or more to the heart of the question -- what does a data scientist do, and what do they need to know?

Hilary Mason and Chris Wiggins took a crack at answering that a couple of years ago. They break down data science, the process, into 5 steps:

Obtain the data: in their case from Web APIs.
Scrub the data: Look for missing data, bad data, outlier. Regularize text data (for instance locations: is "CA" California, or Canada? What about "Cal.", "Ca", "California", "San Francisco", etc..).
Explore. And visualize. Here and during the scrub step is where I might start thinking about the best representations of the data, for modeling. Here is where I begin variable selection.
Model. And evaluate. This is where the statistics and machine learning knowledge comes in.
Interpret. And disseminate.

That's basically the breakdown most of us would give. Their focus is on web analysis and on data collection over the web; generally my focus has been on clients who have the data (albeit in some completely cryptic form); it's our job to wring some insight from it -- somehow. So in addition to the emphasis that Mason and Wiggins place on scripting languages and unix tools, I would also add knowledge of SQL, and a tool like R that can access data directly from the database for analysis. My colleague John Mount would also add that version-control is a must. As with software engineering, data science is a process where "that one last tweak" to the model or to the data handling can turn out to be a tweak too many...

Beyond the tools, and the technical details, though -- what would I add?

I would add that the process is a loop; more than that, it's loops within loops. Obtain-Scrub-Explore is often one loop. Scrub (Represent)-Explore-Model can be another loop. It always depends.

I would add that a healthy understanding of the business processes that generate the data is essential -- otherwise you are apt to "discover" things in the data that everyone (that is, your client) already knows, because they are known artifacts of the business process. The insights in data are like degrees of freedom. Don't eat up your degrees of freedom on known phenomena. If you don't have that domain knowledge yourself, make sure your client partners you with a contact who does.

I would add that a solid understanding of statistics fundamentals is essential (and the whole Win-Vector blog attests to how much time we spend thinking about fundamentals), but stat and machine learning are not the core of the job. The real science, in my opinion -- the part where you form hypotheses, test them, revise them -- comes less in the modeling and more in the scrub and explore steps. Why does this branch of the bank report recoveries where they never reported losses? What is that "profit" column reporting, really? Does gross national product really predict mortgage defaults, or is it just a proxy variable for time (and in the recent economy, time predicts mortgage default rate pretty well)?

And there is more science after the modeling, during the evaluation phase. Or more prosaically: the debug phase. Why does the model report absolute nonsense on this one subset of the data? Is the error in the modeling? The data handling? The programming? The "modeling" step itself is actually a very small, and relatively straightforward, part of the overall process.

No one ever wants to hear this. We all come into the job hoping to wield support vector machines or neural nets like Wonder Woman wields her magic lasso: we capture the data, and then wrest the truth out of it, willy-nilly. I wish. I'd love to wear those cool bullet-deflecting bracelets, too.

Art: Alex Ross

My point here is that answering the original question is more a discussion of process than a checklist of skills to have and technologies to be familiar with.

What would you add? What do you think a data scientist needs to know?

On Writing Technical Articles for the Nonspecialist

2012-09-04T00:00:00Z

I came across a post from Emily Willingham the other day: "Is a PhD required for Good Science Writing?". As a science writer with a science PhD, her answer is: is it not required, and it can often be an impediment. I saw a similar sentiment echoed once by Lee Gutkind, the founder and editor of the journal Creative Nonfiction. I don't remember exactly what he wrote, but it was something to the effect that scientists are exactly the wrong people to produce literary, accessible writing about matters scientific.

Photo: John Mount

I don't agree with Gutkind's point, but I can see where it comes from. Academic writing has a reputation for being deliberately obscure and prolix, jargonistic. Very few people read journal papers for fun (well, except me, but I'm weird). On the other hand, a science writer with a PhD has been trained for critical thinking, and should have a nose for bullpucky, even outside their field of expertise. This can come in handy when writing about medical research or controversial new scientific findings. Any scientist -- any person -- is going to hype up their work. It's the writer's job to see through that hype.

I'm not a science writer in the sense that Dr. Willingham is. I write statistics and data science articles (blog posts) for non-statisticians. Generally, the audience that I write for is professionally interested in the topic, but aren't necessarily experts at it. And as a writer, many of my concerns are the same as those of a popular science writer.

I want to cut through the bullpucky. I want you, the reader, to come away understanding something you thought you didn't -- or even couldn't -- understand. I want you, the analyst or data science practitioner, to understand your tools well enough to innovate, not just use them blindly. And if I'm writing about one of my innovations, I want you to understand it well enough to possibly use it, not just be awed at my supposed brilliance.

I don't do these things perfectly; but in the process of trying, and of reading other writers with similar objectives, I've figured out a few things.

It's not a research paper; don't write it like a research paper.

To the outsider (and sometimes, to the insider), academic writing is a giant exercise in gamesmanship. The goals are to demonstrate that you are smarter than your peers, and your research is innovative and novel. Those goals impede clarity; after all, if it's hard to read, it must be difficult material, and you must be one smart cookie.

When you are writing for the public, or for the practitioner, you usually aren't writing about something you invented. This frees you from the pressure of appearing novel, and the topic doesn't have to seem profound. You don't have to try to look smart, either. By definition, you know something the reader doesn't -- and if you can explain it so that it seems obvious in hindsight, you actually look that much more clever.

Channel your inner undergrad.

This is related to the first point. Your readers are not your research peers, but they aren't stupid, either. They just have a different set of expertise. They won't know all the acronyms or the standard symbology, they won't know all the terminology or all the logic shortcuts (and occasional sloppy misuse of terminology) that people in the field are accustomed to. They are, however, motivated to learn the subject matter. It's your job to make it all make sense.

This is where I have an advantage in writing about statistics: my PhD isn't in statistics. I learned it after I started working, because I had to. I remember a good deal of frustration with the general presentations of standard material given in textbooks. And I can remember even more frustrations with the "insider" style of writing in research papers -- often a lot of hard work for not a lot of reward. The Statistics to English series of blog posts arose from that experience. It doesn't have to be that hard.

Explain everything. If you are going to talk about p-values, for example, then define what they are; define significance, or at least point to a readable reference. Don't expect your readers to know that π means "vector of probabilities" and not "the area of a unit radius circle." In any technical field, a clear explanation of definitions -- especially terms and symbols that are used differently in different fields, like "entropy" or "likelihood" -- is worth a lot. It may not seem like much, but believe me, your readers will thank you.

If an explanation helps make sense of a concept to you, it will probably make sense to someone else.

... and therefore, it will be helpful to someone, if not everyone. A related point to this is that parroting the textbook or research paper explanations is not always helpful, no matter how official or technical it sounds.

An example: the definition of likelihood (or likelihood function) from The Cambridge Dictionary of Statistics is as follows:

The probability of a set of observations given the value of some parameter or set of parameters.

The dictionary goes on to give an example, the likelihood of a random sample of n observations, x1,..x2,...xn with probability distribution f(x,θ):

This makes perfect sense, from a 50,000 foot point of view, especially if you are in the habit of thinking statistically. But what if you aren't? Or if you want to actually calculate a specific likelihood for a specific purpose? Like the person who asked a question about likelihood versus probability here. This person received several excellent answers, most of which were elaborations of the Cambridge definition, with variations on how the likelihood formula was written. This seems to have helped the original questioner; but I can tell you that back in the days when I was struggling to learn these concepts, it wouldn't have helped me. I learn by concrete examples. Like this (borrowed from one of the answers at the link):

I have an unfair coin, and I think that the probability that it will land heads is p. I flip the coin n times, and I record whether it lands heads (x_i=1), or whether it lands tails (x_i=0). The likelihood of observing my series of coin flips, given that I have guessed probability p correctly is:

Here, I'm using the notation L(x|p) to emphasize that the likelihood of the set of observations X is dependent on my "model" -- the estimate for p. If the likelihood is high, I have guessed p correctly; if it is low, I need to re-estimate p.

We can generalize this to any set of observations X that lead to a binary outcome, and any model for the probability, P(x).

Again, if the likelihood isn't high, then we need to adjust our model P(x), probably by tweaking some parameter or parameters θ within the model. This leads us back to the original Cambridge definition.

My formula is not as general as the Cambridge formula (or the formulas given by the people who answered the question in my link above), and it may still not be clear enough for everyone. Still, it helped me; this is the formula I use to explain the use of likelihood in deriving logistic regression. Judging by Win-Vector's blog stats, it helps other people out there, too.

Few things are "obvious."

But after all, the most successful device in mathmanship is to leave out one or two pages of calculations and for them substitute the word "hence," followed by a colon. This is guaranteed to hold the reader for a couple of days figuring out how you got hither from hence. Even more effective is to use "obviously" instead of "hence," since no reader is likely to show his ignorance by seeking help in elucidating anything that is obvious. This succeeds not only in frustrating him but also in bringing him down with an inferiority complex, one of the prime desiderata of the art.

-- Nicolas Vanserg, "Mathmanship" (1958). Originally published in American Scientist, collected in A Stress Analysis of a Strapless Evening Gown: Essays for a Scientific Age. Sorry, couldn't find the essay online.

If it is "obvious" enough to be explained concisely, then explain it. If the calculation or derivation is short, then spell it out. Otherwise, use another phrase like "it happens to be the case", or "it can be shown," with references -- or at least cop to the fact that it's a messy calculation. Some people will complain about how long your posts are; but there will also be an army of students and other novices who will be grateful to you, because they finally "get it."

And finally:

No matter how hard you try, someone will think you stink. Let it go.

Even if you don't write your article like a research paper, someone out there will read it (or criticize it) as if it were. If you try to define every concept and explain every chain of reasoning, you will get snarky "TLDR" (too long, didn't read) comments, or comments to the effect that it was a lot of reading for a point that was "obvious." If you express an opinion, no matter how mildly or with any number of qualifications (for example, my colleague John Mount's article on why he dislikes dynamic typing), you will get sarcastic comments from those who hold the opposite opinion, on why you are just wrong, or why the issues you point out are your fault, not (e.g.) dynamic typing's fault. You will get people hurling back at you points that you already addressed in the post.

So fine, some people don't read (or are too impatient or closed-minded to read); they aren't your readers. Just let it go and move on.

Being the concrete-minded person that I am, these points are addressed to my specific situation; but I hope that they are useful to other science writers and technical writers as well. I'm sure that I've violated many of these points in my own writing; hopefully the more I keep at it, the better my writing gets.

	s1	s2	s3	s4	x
42	1	0	0	0	1
43	-1	1	0	0	2
44	0	1	0	0	3
45	1	1	0	0	4
46	-1	-1	1	0	5
47	0	-1	1	0	6
48	1	-1	1	0	7
49	-1	0	1	0	8
50	0	0	1	0	9
51	1	0	1	0	10
52	-1	1	1	0	11
53	0	1	1	0	12
54	1	1	1	0	13
55	-1	-1	-1	1	14
56	0	-1	-1	1	15
57	1	-1	-1	1	16
58	-1	0	-1	1	17
59	0	0	-1	1	18
60	1	0	-1	1	19
61	-1	1	-1	1	20
62	0	1	-1	1	21
63	1	1	-1	1	22
64	-1	-1	0	1	23
65	0	-1	0	1	24
66	1	-1	0	1	25
67	-1	0	0	1	26
68	0	0	0	1	27
69	1	0	0	1	28
70	-1	1	0	1	29
71	0	1	0	1	30
72	1	1	0	1	31
73	-1	-1	1	1	32
74	0	-1	1	1	33
75	1	-1	1	1	34
76	-1	0	1	1	35
77	0	0	1	1	36
78	1	0	1	1	37
79	-1	1	1	1	38
80	0	1	1	1	39
81	1	1	1	1	40

men	women	children	total_pop	bushels
20	0	80	100	100
17	5	78	100	100
14	10	76	100	100
11	15	74	100	100
8	20	72	100	100
5	25	70	100	100
2	30	68	100	100

	s1	s2	s3	s4	x
42	1	0	0	0	1
43	-1	1	0	0	2
44	0	1	0	0	3
45	1	1	0	0	4
46	-1	-1	1	0	5
47	0	-1	1	0	6
48	1	-1	1	0	7
49	-1	0	1	0	8
50	0	0	1	0	9
51	1	0	1	0	10
52	-1	1	1	0	11
53	0	1	1	0	12
54	1	1	1	0	13
55	-1	-1	-1	1	14
56	0	-1	-1	1	15
57	1	-1	-1	1	16
58	-1	0	-1	1	17
59	0	0	-1	1	18
60	1	0	-1	1	19
61	-1	1	-1	1	20
62	0	1	-1	1	21
63	1	1	-1	1	22
64	-1	-1	0	1	23
65	0	-1	0	1	24
66	1	-1	0	1	25
67	-1	0	0	1	26
68	0	0	0	1	27
69	1	0	0	1	28
70	-1	1	0	1	29
71	0	1	0	1	30
72	1	1	0	1	31
73	-1	-1	1	1	32
74	0	-1	1	1	33
75	1	-1	1	1	34
76	-1	0	1	1	35
77	0	0	1	1	36
78	1	0	1	1	37
79	-1	1	1	1	38
80	0	1	1	1	39
81	1	1	1	1	40

men	women	children	total_pop	bushels
20	0	80	100	100
17	5	78	100	100
14	10	76	100	100
11	15	74	100	100
8	20	72	100	100
5	25	70	100	100
2	30	68	100	100

Nina B. Zumel

Testing Comments on the Blog

Digital Difficulties

Solution #

The Brute Force Solution #

An Elegant Modern Solution #

Find the Least Common Multiple (LCM) of the integers from 2 to 18 #

Filter all the multiples of m #

But How Would Dudeney Solve This? #

A Trick For Checking Divisibility by 11

Preliminaries: Modular Arithmetic #

Modular Arithmetic with Negative Numbers #

More Handy Facts #

The Proof #

Testing it Out #

A Trick For Checking Divisibility by Powers of 2

The Proof #

Fun with Mental Calculations #

Is M = 9,937,654,480 divisible by 8? #

Is M = 9,937,654,480 divisible by 16? #

Is M = 9,937,654,480 divisible by 32? #

Fun, but is it Practical? #

Dyson’s Algorithm for the Twelve Coins Problem

The Algorithm #

Back to the 12 coins #

Reference #

The Twelve Coins Puzzle

Our Solution #

Notation #

Some transformation rules #

Transformation 1. G is a terminal state #

Transformation 2. H and L can only go to G, not to the opposite weight #

Transformation 3. Transformation on a balanced weighing #

Transformation 4. Transformation on an unbalanced weighing #

Some Useful Lemmas #

Lemma 1. L2H and H2L can be resolved in one weighing if a dud is known to be present. #

Lemma 2. HLG can be resolved in one weighing if a dud in known to be present. #

Lemma 3. ?G can be resolved in one weighing. #

The Solution Procedure #

If the scale is balanced on the first weighing #

If the scale is not balanced on the first weighing #

Some Further Discussion #

Finding x: or, Back To the Four Weights Problem

Converting x to a base-n representation #

Converting x to signed trinary #

The Wine Thief Problem

Solution #

"Half-symmetric" Solutions #

Coin Puzzles

Kissing Coins #

Making Change #

Solutions #

Kissing Coins #

Making change #

The Perplexed Banker

The Solution #

Bachet’s Four Weights Problem

The Solution #

1. The weights (w1=1,w2=3) can weigh any object from 1 to 4 pounds. #

2. The case of three weights #

3. Finally, the case of four weights #

100 Bushels of Corn

The Puzzle #

The Solution #

1. c is even. #

2. w is a multiple of 5. #

3. w≤30 #

I Added Margin Notes to my Blog

Deciding on the Approach #

Let's do it! #

1. Add marginnote.css to wherever your blog keeps its stylesheets. #

2. Modify the post template. #

3. (If needed) Widen the body width. #

4. Define the shortcode. #

Shortcomings of the approach #

Only margin notes, and only short ones. #

They don't cos-play as footnotes. #

On the positive side... #

Playing With Sidenotes

Adjusting Saturated Multivariate Linear Models

Transformation 1. $G$ is a terminal state #

Transformation 2. $H$ and $L$ can only go to $G$ , not to the opposite weight #

Lemma 1. $L^{2} H$ and $H^{2} L$ can be resolved in one weighing if a dud is known to be present. #

Lemma 2. $H L G$ can be resolved in one weighing if a dud in known to be present. #

Lemma 3. $? G$ can be resolved in one weighing. #

Converting $x$ to a base-n representation #

Converting $x$ to signed trinary #

1. The weights $(w_{1} = 1, w_{2} = 3)$ can weigh any object from 1 to 4 pounds. #

1. $c$ is even. #

2. $w$ is a multiple of 5. #

3. $w \leq 30$ #

1. Add `marginnote.css` to wherever your blog keeps its stylesheets. #

	s1	s2	s3	s4	x
42	1	0	0	0	1
43	-1	1	0	0	2
44	0	1	0	0	3
45	1	1	0	0	4
46	-1	-1	1	0	5
47	0	-1	1	0	6
48	1	-1	1	0	7
49	-1	0	1	0	8
50	0	0	1	0	9
51	1	0	1	0	10
52	-1	1	1	0	11
53	0	1	1	0	12
54	1	1	1	0	13
55	-1	-1	-1	1	14
56	0	-1	-1	1	15
57	1	-1	-1	1	16
58	-1	0	-1	1	17
59	0	0	-1	1	18
60	1	0	-1	1	19
61	-1	1	-1	1	20
62	0	1	-1	1	21
63	1	1	-1	1	22
64	-1	-1	0	1	23
65	0	-1	0	1	24
66	1	-1	0	1	25
67	-1	0	0	1	26
68	0	0	0	1	27
69	1	0	0	1	28
70	-1	1	0	1	29
71	0	1	0	1	30
72	1	1	0	1	31
73	-1	-1	1	1	32
74	0	-1	1	1	33
75	1	-1	1	1	34
76	-1	0	1	1	35
77	0	0	1	1	36
78	1	0	1	1	37
79	-1	1	1	1	38
80	0	1	1	1	39
81	1	1	1	1	40

men	women	children	total_pop	bushels
20	0	80	100	100
17	5	78	100	100
14	10	76	100	100
11	15	74	100	100
8	20	72	100	100
5	25	70	100	100
2	30	68	100	100