Writing-style fingerprints

Small words give you away

If you wanted to guess who wrote a letter, you might look for big, unusual words. Researchers found the opposite works better: the tiny words. Words like "upon", "by", "also" and "there" turn up in every text on every topic, and each writer uses them at their own steady rate without noticing.

The classic case

In 1787 and 1788, 85 essays called the Federalist Papers were published under one shared pen name. Most were later known to be by Alexander Hamilton or James Madison, but both men's lists claimed twelve of the same papers. In the 1960s two statisticians, Frederick Mosteller and David Wallace, counted function words. One striking clue: Hamilton wrote "upon" far more often than Madison, and Madison wrote "whilst" where Hamilton wrote "while". Their conclusion was that Madison very probably wrote all twelve disputed papers.

Our practice papers

The real papers are public domain, but this lab uses generated practice papers from practice_papers() so it runs quickly and offline. Each one is word salad built with an author's habits: the rates are invented, with "upon" and "while"/"whilst" pointing the same way as in the historical study. The same code would work on the real texts. Each paper is a dict: {"id": "H03", "author": "Hamilton", "text": "..."}, and the disputed ones are named after the real disputed numbers, such as D49.

Rates per 1,000 words

A long paper naturally has more of every word than a short one, so raw counts are unfair. Instead, compute a rate: how many times per 1,000 words.

text_words = ["upon", "the", "law", "upon"]     # 4 words, 2 of them "upon"
rate = 1000 * text_words.count("upon") / len(text_words)   # 500.0

Python's .count(x) counts how many times x appears in a list. First clean the text: text.lower() makes it lower case, .replace(",", " ") swaps commas for spaces, and .split() cuts it into words at spaces.

Then the method is the same as for typists: average each author's rates into a profile, and give each disputed paper to the author whose profile is closest.

function wordRates(text, words) {
  const all = text.toLowerCase().replace(/[,.]/g, " ").split(/\s+/).filter(Boolean);
  const rates = {};
  for (const w of words) {
    rates[w] = 1000 * all.filter(x => x === w).length / all.length;
  }
  return rates;
}

func wordRates(text string, words []string) map[string]float64 {
    clean := strings.NewReplacer(",", " ", ".", " ").Replace(strings.ToLower(text))
    all := strings.Fields(clean)
    counts := map[string]int{}
    for _, w := range all {
        counts[w]++
    }
    rates := map[string]float64{}
    for _, w := range words {
        rates[w] = 1000 * float64(counts[w]) / float64(len(all))
    }
    return rates
}

The defence

If you ever need to write something truly anonymous (a whistle-blowing tip, a review of your own employer), style matching is the risk to plan for. Practical steps: keep it short, because short texts carry fewer clues; write it in a deliberately plain style unlike your usual one; and avoid your pet phrases and spellings. Running your text through a translation tool and back, or asking an on-device writing assistant to rephrase it, also scrambles many habits. None of these is perfect, so the safest anonymous text is the one with the least of you in it.