Trachtenberg Speed System Explained: Rules for 11, 12 and Any Number

The Trachtenberg speed system replaces the multiplication table with short digit-by-digit rules. To multiply by 11, add each digit to its right-hand neighbour. To multiply by 12, double the digit and add the neighbour. For any multiplier, add units and tens of small products in pairs. It is correct and general, but its speed was never measured.

This post sets out every rule in the 1960 English book, The Trachtenberg Speed System of Basic Mathematics, translated and adapted by Ann Cutler and Rudolph McShane, and works each rule on the fixed problems from our mathematics traditions series: 98 x 97, 47 x 53, 386 x 524, 85², √7,744, 7,429 ÷ 37 and 1/19 as a decimal. You can set the results side by side with the Vedic, Chinese and Japanese comparison.

It also separates Jakow Trachtenberg's documented life from the story in the book's foreword, using archival research published in 2023. Every answer, digit, carry and running total below was computed with a Python simulator that follows the book's rules literally; the script is in the walkthrough.

Key takeaways

• One idea runs through the system. Each answer digit comes from a digit of the multiplicand (the "number") and the digit to its right (the "neighbour"). The rules for 11, 12, 5, 6, 7, 8 and 9 combine those two digits in different ways, and each follows from simple algebra. For example, 7,429 x 11 = 81,719 and 7,429 x 6 = 44,574.
• The general methods are cross multiplication with a twist. The "direct" method sums outside and inside pairs, which is the same arithmetic as the Vedic Urdhva-Tiryagbhyam. The "two-finger" method splits each product into units and tens, so for 98 x 97 the largest running total falls from 140 to 15 and the largest carry from 14 to 1. The price is twice as many digit lookups.
• Addition never counts above 11. Each column produces a running total and a tick count, and the ticks give a built-in check that can point to the exact column with an error.
• Division works too. With the book's "trouble-saving device" (divide by 2 instead of 1 for the divisor 19), all 18 digits of 1/19 = 0.052631578947368421 came out right first time.
• The speed claims were never tested. The foreword's 20 per cent time saving and 99 per cent accuracy cite no study, and we found no peer-reviewed trial. Step counts are the honest measure, and this post gives them for every problem.
• The life story needs care. Archival research published in 2023 confirms that the Vienna Gestapo registered Trachtenberg in 1940, that he reached Switzerland in 1945 and that he died in Zurich on 26 October 1951. It also found he was not held in Sachsenhausen or Auschwitz, but in camps in Yugoslavia.

Who was Jakow Trachtenberg? The documented record and the legend

Most of what people know about Trachtenberg comes from the foreword of the 1960 book. It says he was born in Odessa on 17 June 1888, graduated from the Mining Engineering Institute in St Petersburg, became chief engineer of the Obukhov shipyards with 11,000 men under him while still in his twenties, fled the revolution in 1919 dressed as a peasant, became a leading writer on Russian affairs in Berlin, fled to Vienna in 1934, was arrested after the German annexation of Austria, escaped to Yugoslavia, was caught by the Gestapo and sent to a concentration camp, spent "almost seven years" in prison, built the system in his head without paper, escaped from Leipzig, was recaptured, sent to a labour camp in Trieste, and finally escaped to Switzerland early in 1945 with the help of his wife.

The foreword names no camp, gives few dates and cites no documents. That does not make it false, but it needed checking, and in 2023 someone did.

What the archives show

On 2 July 2023, Radio Svoboda published a long investigation by the Munich-based historian Igor Petrov, titled "Вычисляя Трахтенберга" ("Calculating Trachtenberg"). Petrov worked from the Swiss Federal Archives, the political archive of the German Foreign Office and the database of the Documentation Centre of Austrian Resistance (DÖW). His main findings, summarised:

• Berlin in the 1920s and 1930s. A German Foreign Office note from around 1930 describes him as a Russian émigré engineer in Charlottenburg who published a magazine on the Soviet Union, brokered goods to it and taught languages by his own method. That fits the foreword.
• His marriage. He married Alice, born von Bredow, in 1930. Her family had lived in Russia before the revolution.
• Vienna, 1940. The Vienna Gestapo registered him as a Jew in 1940, and his registration photographs survive in the DÖW database. Petrov says a record stating that he was sent to a concentration camp at that time is not correct.
• 1940 to 1945. In his own 1945 Swiss questionnaire, Trachtenberg wrote that he was arrested and released in Vienna, went to Zagreb in July 1940, was interned by the Yugoslav authorities in a camp in Slovenia, was arrested by the Gestapo again in February 1944 and was sent to work at a factory in Leipzig. His wife's passport shows visas for Zagreb and Leipzig in April 1944. Petrov concludes he was in neither Sachsenhausen nor Auschwitz (both named in retellings) but was held in camps on Yugoslav territory, and that 1940 to 1945 still needs research.
• Switzerland, 1945. The couple moved from a camp near the Italian border to Zurich. In May 1945 Trachtenberg wrote to the Swiss authorities offering his calculation method to the state free of charge.
• The institute. His letterhead later named an institute for instant mental calculation, and the police asked how long it had existed, which suggests it was not registered at first. A Swiss mathematician who reviewed the method judged that it eased mental arithmetic but was not a mathematical discovery.
• His death. A death notice in the Swiss Federal Archives records that he died in Zurich of angina on 26 October 1951. Many popular accounts give 1953; the English Wikipedia article gave both years when we checked.

What the library catalogues show

The German National Library (DNB) catalogue lists Trachtenberg's publications with places and dates:

So the system appeared in German booklets from 1946, years before the American book, and several came out after 1951 under his widow's or the institute's imprint.

What we can say and what we cannot

None of this changes the arithmetic, which works, as the rest of this post shows. But retell the documented version.

The English book

The 1960 Doubleday edition (Library of Congress Catalog Card Number 60-13513) is "translated and adapted by Ann Cutler and Rudolph McShane", with the copyright in Ann Cutler's name. Its eight chapters cover single-digit multiplication, the direct method, the two-finger method, addition, division, squares and square roots, an algebraic description and a postscript. Souvenir Press published it in Britain and reissued it in the 1980s.

The foreword includes a showcase: a girl computes 735,352,314 x 11 = 8,088,875,454, and a boy computes 5,132,437,201 x 452,736,502,785 = 2,323,641,669,144,374,104,785 in seventy seconds. Both products are correct; we checked them in Python. Nothing in the book says the seventy seconds was independently timed.

The core idea: number, neighbour and a zero in front

1. Write a zero in front of the multiplicand. 386 becomes 0386. The zero makes room for the leftmost digit of the answer.
2. Work from right to left, writing each answer digit under a digit of the multiplicand.
3. The "number" is the digit directly above the answer digit you are about to write.
4. The "neighbour" is the digit to the right of the number. The rightmost digit has none, so it counts as zero.
5. Carries are dots. The book marks a carry with a dot beside the answer digit; we write "carry 1" in words.
6. "Half" means the simplified half. Drop the fraction: half of 7 is 3, half of 1 is 0, half of 8 is 4.

So for 0386, reading right to left:

position:     0   3   8   6
              |   |   |   |
step 1:                   number 6, neighbour none (0)
step 2:               number 8, neighbour 6
step 3:           number 3, neighbour 8
step 4:       number 0, neighbour 3

Every rule in chapter one is a formula in two variables, the number and the neighbour.

Why the neighbour rules work

The book gives the algebra in its seventh chapter. Multiplying by a digit m puts a × m in the position of each digit a. Its units part stays there; its tens part moves one place left, to the position where a is the neighbour. So every answer digit is:

(units of number × m) + (tens of neighbour × m) + carry.

The single-digit rules are shortcuts for computing those two parts without the times table.

• 11. 11a = 10a + a. The "a" stays in place and the "10a" moves left, so each position gets the number plus the neighbour.
• 12. 12a = 10a + 2a. Each position gets twice the number plus the neighbour.
• 5. 5a = 10 × half(a) + (5 if a is odd). The 5 for odd digits stays in place; half of a moves left as a tens value. So each position gets half the neighbour, plus 5 if the number is odd. The number itself is only looked at, not added.
• 6. 6a = a + 5a. Combine the rule for 5 with the number itself: the number, plus 5 if it is odd, plus half the neighbour.
• 7. 7a = 2a + 5a. Twice the number, plus 5 if it is odd, plus half the neighbour.
• 9. 9N = 10N − N. Subtracting digit by digit would need borrowing, so the rule subtracts from 10 at the right-hand end and from 9 everywhere else (the complements), adds the neighbour (the shifted 10N), and repairs the left end by taking 1 off the leftmost digit.
• 8. 8N = 10N − 2N. The same as 9, but doubled complements, and 2 off the leftmost digit.
• 4 and 3. These combine the complement pattern with the half and 5 idea: 4 behaves like 9 with half the neighbour, and 3 like 8 with half the neighbour.

Each rule rewrites an exact identity, so errors come only from slips, which is why the book stresses checking.

Multiplying by 11: add the neighbour

The book states the rule in three parts, then folds them into one: "add the neighbour".

386 x 11 = 4,246

  0 3 8 6  x 11
        6      number 6, no neighbour: write 6
      4 6      8 + 6 = 14: write 4, carry 1
    2 4 6      3 + 8 = 11, plus carry 1 = 12: write 2, carry 1
  4 2 4 6      0 + 3 = 3, plus carry 1 = 4: write 4

7,429 x 11 = 81,719

Step  Number  Neighbour  Number + neighbour  Plus carry  Write  Carry
1     9       none       9                   9           9      0
2     2       9          11                  11          1      1
3     4       2          6                   7           7      0
4     7       4          11                  11          1      1
5     0       7          7                   8           8      0

Five steps, and nothing held above 11. The usual way does the same additions but writes two rows first.

Multiplying by 12: double the number, add the neighbour

386 x 12 = 4,632

  0 3 8 6  x 12
        2      2 x 6 = 12: write 2, carry 1
      3 2      2 x 8 + 6 = 22, plus 1 = 23: write 3, carry 2
    6 3 2      2 x 3 + 8 = 14, plus 2 = 16: write 6, carry 1
  4 6 3 2      2 x 0 + 3 = 3, plus 1 = 4: write 4

7,429 x 12 = 89,148

Step  Number  Neighbour  2 x number + neighbour  Plus carry  Write  Carry
1     9       none       18                      18          8      1
2     2       9          13                      14          4      1
3     4       2          10                      11          1      1
4     7       4          18                      19          9      1
5     0       7          7                       8           8      0

Digit sums check it: 386 → 8 and 12 → 3, so 8 × 3 = 24 → 6, and 4,632 → 15 → 6.

Multiplying by 6, 7 and 5: halves and the extra 5

These rules use the simplified half and one condition: add 5 if the number (not the neighbour) is odd.

By 6: the number, plus 5 if odd, plus half the neighbour

386 x 6 = 2,316

  0 3 8 6  x 6
        6      6 is even; no neighbour: 6
      1 6      8 even, + half of 6 (3) = 11: write 1, carry 1
    3 1 6      3 is odd: 3 + 5 + half of 8 (4) = 12, + 1 = 13: write 3, carry 1
  2 3 1 6      0 + half of 3 (1) = 1, + 1 = 2: write 2

7,429 x 6 = 44,574

Step  Number  Odd?     Half of neighbour  Total  Plus carry  Write  Carry
1     9       yes, +5  0                  14     14          4      1
2     2       no       4 (half of 9)      6      7           7      0
3     4       no       1 (half of 2)      5      5           5      0
4     7       yes, +5  2 (half of 4)      14     14          4      1
5     0       no       3 (half of 7)      3      4           4      0

By 7: twice the number, plus 5 if odd, plus half the neighbour

386 x 7 = 2,702

  0 3 8 6  x 7
        2      2 x 6 = 12: write 2, carry 1
      0 2      2 x 8 + half of 6 (3) = 19, + 1 = 20: write 0, carry 2
    7 0 2      2 x 3 + 5 + half of 8 (4) = 15, + 2 = 17: write 7, carry 1
  2 7 0 2      0 + half of 3 (1) = 1, + 1 = 2: write 2

7,429 x 7 = 52,003

Step  Number  2 x number  +5 if odd  Half of neighbour  Total  Plus carry  Write  Carry
1     9       18          5          0                  23     23          3      2
2     2       4           0          4                  8      10          0      1
3     4       8           0          1                  9      10          0      1
4     7       14          5          2                  21     22          2      2
5     0       0           0          3                  3      5           5      0

Note the carry of 2 in steps 1 and 4. The rule for 7 is the first one where a carry larger than 1 is common, which is one reason the two-finger method exists.

By 5: half the neighbour, plus 5 if the number is odd

386 x 5 = 1,930

  0 3 8 6  x 5
        0      look at 6: even, so no 5; no neighbour: 0
      3 0      look at 8: even; half of 6 = 3
    9 3 0      look at 3: odd, so 5; half of 8 = 4; 5 + 4 = 9
  1 9 3 0      look at 0: even; half of 3 = 1

No carries at all, and no multiplication. The rule for 5 can never produce a carry, because half a digit is at most 4, and 4 + 5 = 9.

47 x 5 = 235

  0 4 7  x 5
      5      7 is odd: 5; no neighbour
    3 5      4 is even; half of 7 = 3
  2 3 5      0 is even; half of 4 = 2

Multiplying by 9 and 8: subtract from 10, then from 9

These rules have three parts: a first step for the rightmost digit, middle steps, and a last step under the zero in front.

By 9

386 x 9 = 3,474

  0 3 8 6  x 9
        4      10 − 6 = 4
      7 4      9 − 8 = 1, + neighbour 6 = 7
    4 7 4      9 − 3 = 6, + neighbour 8 = 14: write 4, carry 1
  3 4 7 4      last step: 3 − 1 = 2, + carry 1 = 3

7,429 x 9 = 66,861

Step  Digit   Operation  Value  Plus carry  Write  Carry
1     9       10 − 9     1      1           1      0
2     2       9 − 2 + 9  16     16          6      1
3     4       9 − 4 + 2  7      8           8      0
4     7       9 − 7 + 4  6      6           6      0
5     (zero)  7 − 1      6      6           6      0

98 x 9 = 882

  0 9 8  x 9
      2      10 − 8 = 2
    8 2      9 − 9 = 0, + neighbour 8 = 8
  8 8 2      last step: 9 − 1 = 8

By 8

386 x 8 = 3,088

  0 3 8 6  x 8
        8      (10 − 6) x 2 = 8
      8 8      (9 − 8) x 2 = 2, + neighbour 6 = 8
    0 8 8      (9 − 3) x 2 = 12, + neighbour 8 = 20: write 0, carry 2
  3 0 8 8      last step: 3 − 2 = 1, + carry 2 = 3

By 4 and 3, briefly

The book adds 4 and 3 "for the sake of completeness". Their rules are in the summary table below.

386 x 4 = 1,544: 10 − 6 = 4; 9 − 8 = 1, + half of 6 = 4; 9 − 3 = 6, + half of 8 = 10, + 5 because 3 is odd = 15, write 5, carry 1; last step half of 3 = 1, − 1 = 0, + carry 1 = 1.

47 x 3 = 141: (10 − 7) x 2 = 6, + 5 because 7 is odd = 11, write 1, carry 1; (9 − 4) x 2 = 10, + half of 7 = 13, + 1 = 14, write 4, carry 1; last step half of 4 = 2, − 2 = 0, + 1 = 1.

One oddity: in 386 x 3 = 1,158, the last step gives half of 3 minus 2 = −1, and the carry of 2 turns it into 1. Trust the carry.

The single-digit rules on one page

Using the single-digit rules on the problem set

You can already do the multiplications in the problem set with nothing but the rules above, by splitting the multiplier into digits:

• 98 x 97 = 98 x 9 tens + 98 x 7 = 8,820 + 686 = 9,506. The rule for 7 on 98: 2 x 8 = 16, write 6, carry 1; 2 x 9 + 5 + half of 8 = 27, + 1 = 28, write 8, carry 2; half of 9 = 4, + 2 = 6. So 686.
• 47 x 53 = 47 x 5 tens + 47 x 3 = 2,350 + 141 = 2,491.
• 386 x 524 = 386 x 5 hundreds + 386 x 2 tens + 386 x 4 = 193,000 + 7,720 + 1,544 = 202,264.

That works, but it writes partial products, which the book wants to avoid. Chapters two and three show how to go straight to the answer.

The direct method: any number times any number

Chapter two of the book introduces the "direct" method for multipliers of any length. The book says plainly that something like it was probably used by stage calculators before Trachtenberg, who kept their techniques to themselves. It is the same arithmetic as the Vedic Urdhva-Tiryagbhyam ("vertically and crosswise") that we worked in the Indian and Vedic mathematics post, and the order in which a counting board or abacus collects products.

The setup: write as many zeros in front of the multiplicand as the multiplier has digits. Then build the answer from the right. For a two-digit multiplier, each answer digit is the sum of two products, which the book calls the outside pair and the inside pair. The outside pair is the current digit of the multiplicand times the rightmost digit of the multiplier. The inside pair is the next pair of digits moving inwards: the digit to the right of the current one, times the left digit of the multiplier.

47 x 53 = 2,491 by the direct method

  0 0 4 7  x 5 3

  step 1:  7 x 3 = 21                           write 1, carry 2
  step 2:  outside 4 x 3 = 12, inside 7 x 5 = 35
           12 + 35 = 47, + carry 2 = 49          write 9, carry 4
  step 3:  outside 0 x 3 = 0, inside 4 x 5 = 20
           0 + 20 = 20, + carry 4 = 24           write 4, carry 2
  step 4:  carry 2                               write 2

  answer:  2 4 9 1

Four digit products, three additions, and a largest running total of 49.

98 x 97 = 9,506 by the direct method

  0 0 9 8  x 9 7

  step 1:  8 x 7 = 56                            write 6, carry 5
  step 2:  outside 9 x 7 = 63, inside 8 x 9 = 72
           63 + 72 = 135, + carry 5 = 140        write 0, carry 14
  step 3:  inside 9 x 9 = 81, + carry 14 = 95     write 5, carry 9
  step 4:  carry 9                               write 9

  answer:  9 5 0 6

Look at step 2: a running total of 140 and a carry of 14. Large digits mean large numbers in your head, which is the reason for chapter three.

386 x 524 = 202,264 by the direct method

For a three-digit multiplier you put three zeros in front, and the middle answer digits are sums of three products.

Answer position    Products summed                     Sum  Plus carry  Total  Write  Carry
units              6 x 4 = 24                          24   0           24     4      2
tens               8 x 4 = 32, 6 x 2 = 12              44   2           46     6      4
hundreds           3 x 4 = 12, 8 x 2 = 16, 6 x 5 = 30  58   4           62     2      6
thousands          3 x 2 = 6, 8 x 5 = 40               46   6           52     2      5
ten thousands      3 x 5 = 15                          15   5           20     0      2
hundred thousands  none                                0    2           2      2      0

Nine products, eight additions, a largest running total of 62 and a largest carry of 6, the same as the Vedic crosswise count, since it is the same computation.

The two-finger method: units and tens

Chapter three adds what the book calls the "two-finger" method, which it says might equally be called the "units-and-tens" method. The idea is to stop large numbers from ever forming.

Every product of two digits is at most 81, so it has a tens digit and a units digit. The book treats every product as two digits, writing 2 x 3 as 06. Now take a pair of adjacent digits in the multiplicand, such as 3 and 8, and one multiplier digit, such as 4:

• multiply the left digit of the pair (3) by 4 and keep only the units: 3 x 4 = 12, keep 2 (the book marks this with a small "u");
• multiply the right digit (8) by 4 and keep only the tens: 8 x 4 = 32, keep 3 (marked "T");
• add them: 2 + 3 = 5.

The book calls 5 the pair-product of 38 x 4. It is not ordinary multiplication: you get one digit out of a pair. It works because of the algebra we saw earlier. The units of a digit's product belong in its own position, and the tens of its right-hand neighbour's product move up into the same position. The two fingers are literal: one finger on the digit whose units you take, one on the neighbour whose tens you take.

For a multiplier with several digits, each answer digit is the sum of one pair-product per multiplier digit, with the pairs sliding one place to the right for each step left in the multiplier, exactly as the outside and inside pairs did. Because each pair-product is at most 9 + 8 = 17 and usually much less, the sums stay small.

98 x 97 = 9,506 by the two-finger method

  0 0 9 8  x 9 7

98 x 97: one pair-product per multiplier digit, then add
units:
   x7  pair 8|-:  u(8x7=56)=6  T(0x7=00)=0  -> 6
   sum 6 + carry 0 = 6: write 6, carry 0
tens:
   x7  pair 9|8:  u(9x7=63)=3  T(8x7=56)=5  -> 8
   x9  pair 8|-:  u(8x9=72)=2  T(0x9=00)=0  -> 2
   sum 10 + carry 0 = 10: write 0, carry 1
hundreds:
   x7  pair 0|9:  u(0x7=00)=0  T(9x7=63)=6  -> 6
   x9  pair 9|8:  u(9x9=81)=1  T(8x9=72)=7  -> 8
   sum 14 + carry 1 = 15: write 5, carry 1
thousands:
   x9  pair 0|9:  u(0x9=00)=0  T(9x9=81)=8  -> 8
   sum 8 + carry 1 = 9: write 9, carry 0
answer: 9,506

The direct method held 140 and carried 14. The two-finger method never holds more than 15 or carries more than 1, at the cost of 8 half-product lookups instead of 4 products.

47 x 53 = 2,491 by the two-finger method

47 x 53: one pair-product per multiplier digit, then add
units:
   x3  pair 7|-:  u(7x3=21)=1  T(0x3=00)=0  -> 1
   sum 1 + carry 0 = 1: write 1, carry 0
tens:
   x3  pair 4|7:  u(4x3=12)=2  T(7x3=21)=2  -> 4
   x5  pair 7|-:  u(7x5=35)=5  T(0x5=00)=0  -> 5
   sum 9 + carry 0 = 9: write 9, carry 0
hundreds:
   x3  pair 0|4:  u(0x3=00)=0  T(4x3=12)=1  -> 1
   x5  pair 4|7:  u(4x5=20)=0  T(7x5=35)=3  -> 3
   sum 4 + carry 0 = 4: write 4, carry 0
thousands:
   x5  pair 0|4:  u(0x5=00)=0  T(4x5=20)=2  -> 2
   sum 2 + carry 0 = 2: write 2, carry 0
answer: 2,491

No carries at all. Every answer digit is simply written down. The largest sum is 9.

386 x 524 = 202,264 by the two-finger method

  0 0 0 3 8 6  x 5 2 4

386 x 524: one pair-product per multiplier digit, then add
units:
   x4  pair 6|-:  u(6x4=24)=4  T(0x4=00)=0  -> 4
   sum 4 + carry 0 = 4: write 4, carry 0
tens:
   x4  pair 8|6:  u(8x4=32)=2  T(6x4=24)=2  -> 4
   x2  pair 6|-:  u(6x2=12)=2  T(0x2=00)=0  -> 2
   sum 6 + carry 0 = 6: write 6, carry 0
hundreds:
   x4  pair 3|8:  u(3x4=12)=2  T(8x4=32)=3  -> 5
   x2  pair 8|6:  u(8x2=16)=6  T(6x2=12)=1  -> 7
   x5  pair 6|-:  u(6x5=30)=0  T(0x5=00)=0  -> 0
   sum 12 + carry 0 = 12: write 2, carry 1
thousands:
   x4  pair 0|3:  u(0x4=00)=0  T(3x4=12)=1  -> 1
   x2  pair 3|8:  u(3x2=06)=6  T(8x2=16)=1  -> 7
   x5  pair 8|6:  u(8x5=40)=0  T(6x5=30)=3  -> 3
   sum 11 + carry 1 = 12: write 2, carry 1
ten thousands:
   x2  pair 0|3:  u(0x2=00)=0  T(3x2=06)=0  -> 0
   x5  pair 3|8:  u(3x5=15)=5  T(8x5=40)=4  -> 9
   sum 9 + carry 1 = 10: write 0, carry 1
hundred thousands:
   x5  pair 0|3:  u(0x5=00)=0  T(3x5=15)=1  -> 1
   sum 1 + carry 1 = 2: write 2, carry 0
answer: 202,264

The answer, 202,264, matches the direct method and the school algorithm.

Direct versus two-finger, counted

These counts come from the simulator in the walkthrough. An "addition" is any time you combine two values, including adding a carry. A "half" is taking only the units or only the tens of a digit product.

So the two-finger method does not reduce the work; it roughly doubles the small operations. It reduces the size of the numbers you hold and the carries. For mental work that trade can pay; on paper, the direct method is fewer steps.

Addition and the right answer: never count above 11

Chapter four is titled "Addition and the right answer". Its rule is short: never count higher than eleven. As you add down a column, whenever the running total goes above 11, subtract 11, make a small tick beside the digit that pushed you over, and carry on with what is left. Since the running total before adding is at most 11 and a digit is at most 9, you never exceed 20, so "subtract 11" is just "drop the 1 and take one off the units": 16 becomes 5.

At the bottom of each column you have two numbers: the running total and the tick count. The answer comes from these two rows by what the book calls an "L-shaped" addition: each answer digit is the running total, plus the tick count of its own column, plus the tick count of the column to its right, plus any carry.

Why it works: a column that adds to S, with t ticks and running total r, satisfies S = 11t + r = 10t + (t + r). So t + r stays in the column and t moves one column to the left.

Worked example: 7,429 + 386 + 524 + 9,506 = 17,845

            7 4 2 9
              3 8 6
              5 2 4
            9 5 0 6

Column     Digits from top  Running total as you go                       Running total  Ticks
thousands  7, 0, 0, 9       7, 7, 7, 16 → 5 (tick on 9)                   5              1
hundreds   4, 3, 5, 5       4, 7, 12 → 1 (tick on 5), 6                   6              1
tens       2, 8, 2, 0       2, 10, 12 → 1 (tick on 2), 1                  1              1
units      9, 6, 4, 6       9, 15 → 4 (tick on 6), 8, 14 → 3 (tick on 6)  3              2

Now the L-shaped addition, right to left:

Answer column  Running total  Own ticks  Ticks of right-hand neighbour  Carry  Total  Write
units          3              2          0                              0      5      5
tens           1              1          2                              0      4      4
hundreds       6              1          1                              0      8      8
thousands      5              1          1                              0      7      7
ten thousands  0              0          1                              0      1      1

The total is 17,845.

The three-way check

This is the part of Trachtenberg's addition that is genuinely clever, and the reason he used 11 instead of 10. The book computes three sets of check figures:

1. Columns. The digit sum of each column, reduced by casting out nines.
2. Working table. For each column, the running total plus twice the tick count, reduced the same way. Because S = 11t + r, and 11 leaves remainder 2 when divided by 9, S and r + 2t leave the same remainder. So these must match the column figures one by one.
3. Answer. The digit sum of the answer must match the sum of the column check figures.

For our example:

Column     Column digit sum, reduced  Running total + 2 x ticks, reduced  Match
thousands  7 + 0 + 0 + 9 = 16 → 7     5 + 2 = 7                           yes
hundreds   4 + 3 + 5 + 5 = 17 → 8     6 + 2 = 8                           yes
tens       2 + 8 + 2 + 0 = 12 → 3     1 + 2 = 3                           yes
units      9 + 6 + 4 + 6 = 25 → 7     3 + 4 = 7                           yes

The column check figures sum to 7 + 8 + 3 + 7 = 25 → 7, and the answer 17,845 has digit sum 1 + 7 + 8 + 4 + 5 = 25 → 7. Everything agrees.

If steps 1 and 2 disagree, you know which column is wrong without redoing the sum; a check on the total alone only says something is wrong somewhere. Why 11 and not 10? With 10 you could still check r + t by nines. The book says 11 "goes further", and the algebra shows one reason: the running total r is then the column's remainder on division by 11, so the same working table also supports an elevens check.

Adding partial products: 193,000 + 7,720 + 1,544 = 202,264

The same method finishes the long route to 386 x 524. Only one column produces a tick: the thousands column, 3 + 7 + 1 = 11, does not go above 11, so no tick; the hundreds column, 0 + 7 + 5 = 12, ticks once with running total 1. The L-shaped addition then gives 202,264, and the column checks (1, 0, 2, 3, 6, 4 from left to right) sum to 16 → 7, matching 2 + 0 + 2 + 2 + 6 + 4 = 16 → 7.

Checking by nines and by elevens

The book's general checking chapter uses two tools. The digit sum (the remainder after dividing by 9, found by adding digits and casting out nines) is the main one. The elevens remainder (found by alternately adding and subtracting digits from the right) is the backup, and it catches some errors the nines check misses, such as two swapped digits.

For a multiplication a x b = c, the remainders must satisfy (remainder of a) x (remainder of b), reduced, equals the remainder of c. For a division, divisor x quotient + remainder must reproduce the dividend's remainder.

In the last row, 37 leaves 1 on division by 9 and 4 on division by 11; 200 leaves 2 and 2; 29 leaves 2 and 7. A passing check is evidence, not proof: an error that is a multiple of 9 (or 11) slips through, so use both.

Squaring: special types and the cross-product

Chapter six starts with two special types of two-digit numbers that can be squared instantly, with no carrying, then handles the general case.

Special type 1: numbers ending in 5. The last two digits are 25. In front of them, write the first digit times the next larger digit.

85² = 7,225: 8 x 9 = 72, then 25. Two operations: one multiplication and one placement. This is the same rule as the Vedic Ekadhikena Purvena ("by one more than the one before"), and it is just as fast here.

Special type 2: numbers whose tens digit is 5. The last two digits are the square of the units digit. The first two are 25 plus the units digit.

53² = 2,809: 25 + 3 = 28, and 3² = 9 written as 09.

General two-digit numbers. Write three two-digit groups: the square of the first digit, twice the product of the two digits (the doubled "cross-product"), and the square of the last digit. Then "collapse" them by overlapping, adding from the right with carries.

The last row matters for the next problem: 88² = 7,744.

For three-digit numbers the book adds an "open cross-product", the doubled product of the first and last digits, overlapped into the middle. The method is the algebraic identity (a + b + c)² written out by place value, and it generalises in the same way as crosswise multiplication.

Square roots: √7,744 = 88

The book's square root method for a four-digit number gives a two-digit answer. It goes like this.

1. Mark off two digits from the right. 77/44. Work on the 77.
2. First digit of the answer. The largest digit whose square is not larger than 77. 8² = 64, 9² = 81, so the first digit is 8.
3. Subtract its square. 77 − 64 = 13. This is the working figure.
4. Second digit, tentatively. Take half of the working figure, put a zero after it, and divide by the first digit of the answer. Half of 13 is awkward because 13 is odd. The book discusses exactly this case: you can take the smaller half (6) or the larger half (7), and it suggests splitting the difference on average. Taking 6.5, which splits the difference, gives 65, and 65 ÷ 8 = 8, dropping the fraction. The tentative answer is 88.
5. Check and remainder. Square the tentative answer in the book's way, leaving out the first group: for 88 the groups are 64, 128, 64, and you drop the leading 64. Collapse the rest: 128 and 64 give 1,280 + 64 = 1,344. Subtract everything except its last two digits (13) from the working figure: 13 − 13 = 0. Bring down the 44 to make 044, and subtract the remaining 44: the remainder is 0.

So √7,744 = 88 exactly.

What if you take the smaller half? Then step 4 gives 60 ÷ 8 = 7, a tentative answer of 87. The check gives groups 112 and 49, which collapse to 1,169. Then 13 − 11 = 2, bring down 44 to get 244, and 244 − 69 = 175. The book's rule is that the remainder must not be larger than twice the answer. Twice 87 is 174, and 175 is larger, so 7 is too small. Change it to 8, and the remainder becomes 0. This is the method correcting itself, which is one of its good features: a wrong guess cannot survive the check.

This is the school digit-by-digit method in different clothes, with smaller numbers. For a perfect square, inspection is faster: 7,744 ends in 4, so the root ends in 2 or 8; it lies between 80 and 90, and 85² = 7,225 is below 7,744, so it is 88. Trachtenberg's method does not use inspection; it works for any number.

Division: the simple method and the fast method

Chapter five offers two methods of long division. Both are built around checking.

The simple method: build the table first

The simple method writes the divisor ten times in a column by repeated addition, so the multiples are on paper and no times table is needed. Beside the column runs a check column of digit sums, so every addition is verified as you go. The tenth entry must be the divisor with a zero on the end, which is a final check.

For the divisor 37 (digit sum 3 + 7 = 10 → 1):

Multiple  Value  Digit sum  Check column (+1 each time)
1         37     1          1
2         74     2          2
3         111    3          3
4         148    4          4
5         185    5          5
6         222    6          6
7         259    7          7
8         296    8          8
9         333    0 (9)      0 (9)
10        370    1          1 (370 is 37 with a zero)

Then ordinary long division reads the multiples off the table. For 7,429 ÷ 37: 74 is exactly the second multiple, so the first quotient digit is 2 and nothing is left; bring down 2, which is less than 37, so the next digit is 0; bring down 9 to get 29, less than 37 again, so the last digit is 0 with remainder 29. The answer is 200 remainder 29.

The fast method: NT and u products

The fast method avoids the table. It borrows the units-and-tens idea from multiplication and adds a new product, the NT product: for a pair of digits and a multiplier, use the whole first product (N for number) and only the tens of the second (T). For divisor 37 and quotient digit 2: 3 x 2 = 6 in full, 7 x 2 = 14, tens digit 1, so NT = 6 + 1 = 7. The u product is the units digit of the second product: 4.

The cycle, as the book describes it for a two-digit divisor:

1. Partial dividend. Start with the first digit (or two) of the dividend.
2. Quotient digit. Divide the partial dividend by the first digit of the divisor, ignoring the remainder.
3. Subtract NT. Subtract the NT product of the divisor and the new quotient digit from the partial dividend. Put the next digit of the dividend after the result. This two-digit number is the working figure.
4. Subtract u. Subtract the u product from the working figure. The result is the next partial dividend.
5. Repeat. When the dividend runs out, the last partial dividend is the remainder.

Two corrections keep it honest. If NT or u cannot be subtracted, the quotient digit was too large, so reduce it by one. If the next partial dividend is equal to or larger than the divisor, the quotient digit was too small, so increase it.

7,429 ÷ 37 = 200 remainder 29 by the fast method

Step  Partial  ÷3  Digit  NT                  Working figure         u                Next
1     7        2   2      6 + tens of 14 = 7  7 − 7 = 0, then 4: 04  units of 14 = 4  0
2     0        0   0      0                   0, then 2: 02          0                2
3     2        0   0      0                   2, then 9: 29          0                29

Quotient 200, remainder 29. Three cycles, no corrections, and the largest number held is 29.

The book also gives a "trouble-saving device": when the second digit of the divisor is 8 or 9 (it allows 6 or 7 too), divide by the first digit plus one, because the divisor is closer to the next ten. For 37 that would mean dividing by 4. We tried it: in step 1, 7 ÷ 4 gives 1, which is too small (the next partial dividend would be 37, equal to the divisor), so it needs one correction. For 37, the plain method is better. For 19, the device is essential, as the next problem shows.

1/19 as a decimal: 18 cycles of the fast method

Trachtenberg has no special trick for 1/19, unlike the Vedic Ekadhikena Purvena method in the Vedic post, which builds the digits of 1/19 by repeated doubling from the right. Here you simply divide 1.000... by 19 with the fast method.

The divisor's second digit is 9, so use the trouble-saving device and divide each partial dividend by 2 instead of 1. Since 1 is less than 2, take the first two digits, 1 and the first 0 after the decimal point, as the first partial dividend: 10. Because 1 and 10 are both less than 19, the decimal starts 0.0, and the first digit found below is the hundredths digit. In the table, NT is 1 x digit plus the tens of 9 x digit, and u is the units of 9 x digit.

Cycle  Partial  ÷2  Digit  NT          Working  u  Next
1      10       5   5      5 + 4 = 9   10       5  5
2      5        2   2      2 + 1 = 3   20       8  12
3      12       6   6      6 + 5 = 11  10       4  6
4      6        3   3      3 + 2 = 5   10       7  3
5      3        1   1      1 + 0 = 1   20       9  11
6      11       5   5      5 + 4 = 9   20       5  15
7      15       7   7      7 + 6 = 13  20       3  17
8      17       8   8      8 + 7 = 15  20       2  18
9      18       9   9      9 + 8 = 17  10       1  9
10     9        4   4      4 + 3 = 7   20       6  14
11     14       7   7      7 + 6 = 13  10       3  7
12     7        3   3      3 + 2 = 5   20       7  13
13     13       6   6      6 + 5 = 11  20       4  16
14     16       8   8      8 + 7 = 15  10       2  8
15     8        4   4      4 + 3 = 7   10       6  4
16     4        2   2      2 + 1 = 3   10       8  2
17     2        1   1      1 + 0 = 1   10       9  1
18     1        0   0      0           10       0  10

After cycle 18 the partial dividend is 10 again, the same as at the start, so the digits repeat from here. Reading down the digit column:

1/19 = 0.052631578947368421 052631578947368421 ..., a repeating block of 18 digits.

With the device, all 18 digits came out right first time. Without it, dividing by 1 overshoots at every cycle (10 ÷ 1 = 10 is not even a digit), and our simulator needed 19 corrections.

You can also check the result with a property the traditions posts used: the two halves of the repeating block, 052631578 and 947368421, add to 999,999,999. Each digit pair adds to 9.

The whole problem set, Trachtenberg style

Multiplication and division counts come from the simulator; the square root count is ours, by hand.

What the table shows is that Trachtenberg is never stuck. Every problem in the set goes through, including the root and the repeating decimal, with a check at the end. What it does not show is a dramatic shortcut on any of them, apart from 85². On 98 x 97 the Vedic Nikhilam method (deficits 2 and 3 from 100, giving 95 | 06) needs 4 operations and no carries. Trachtenberg has no near-base rule; it treats 98 x 97 like any other product.

How fast is it, really?

The brief for this series is simple: "fast" has to be shown, not asserted. Here is what can and cannot be shown.

What the book claims. The foreword says the system "shortens time for mathematical computations by twenty per cent" and gives "ninety-nine per cent accuracy", with no study, sample or date for either figure, and describes a contest against calculating machines without a source. We do not repeat these as facts.

What we could find. An ERIC database search for "Trachtenberg system", "Trachtenberg method" and "Trachtenberg speed" returned no records, and we found no controlled trial in a peer-reviewed journal. Contrast the soroban and mental abacus, which have a three-year randomised controlled trial with 204 children in India (Barner and colleagues, Child Development, 2016), discussed in our Japanese mathematics post. Even that trial found gains in arithmetic, not in general cognitive ability. Absence of evidence is not evidence that the Trachtenberg system is slow; it means nobody has measured it properly, as far as we can tell.

What the archives add. Petrov reports that a Swiss mathematician found the method helpful but not new, and that an educational assessment worried it asked too much of pupils' memory for the school hours available.

What is measured: competition records. At the 2024 Mental Calculation World Cup in Paderborn, Germany, the top score for multiplying two 8-digit numbers was 25 tasks (correct minus wrong) in 10 minutes, and for adding ten 10-digit numbers 29 tasks in 7 minutes. The published results do not say which methods competitors used, so they tell us nothing about Trachtenberg in particular.

What we can count. The single-digit rules need one small operation per digit and never hold more than 29. The two-finger method kept running totals at 15 or less and carries at 0 or 1 in all three multiplications, at the cost of twice as many lookups. The addition method never holds more than 20 and can locate a wrong column. Whether that makes you faster than someone who knows the times table well has not been tested.

Trachtenberg against the other systems

The Vedic and soroban counts come from our comparison post, and the Chinese counting-board methods for the same problems are in the Chinese mathematics post. The pattern is clear. The Vedic book wins on special numbers. The soroban wins on raw speed after training because the beads carry the memory load. Trachtenberg's niche is in between: a complete, paper-free, table-free system with checks built into every operation, especially good at multiplying long numbers by a single digit and at adding long columns.

A practice plan: six weeks, 15 minutes a day

1. Week 1: 11 and 12, ten problems a day on 4 to 6 digit numbers, checked by digit sums.
2. Week 2: 5, 6 and 7. Drill the simplified half first.
3. Week 3: 9 and 8, then 4 and 3. Watch the last step.
4. Week 4: the direct method, two-digit then three-digit multipliers, answer only.
5. Week 5: the two-finger method, starting with pair-products on random digit pairs, as the book advises.
6. Week 6: addition with ticks, then fast division with divisors ending in 8 or 9.

Keep a log of time and errors per set. That is the only way to know whether the system is fast for you.

Walkthrough: reproduce every number in Python

This script implements the book's rules literally and asserts every answer against Python's own arithmetic. Run it with python3 trachtenberg.py.

# trachtenberg.py: the book's rules, checked against Python arithmetic
def half(d): return d // 2
def odd5(d): return 5 if d % 2 else 0
def U(x): return x % 10
def T(x): return x // 10

def single(n, m):
    """Single-digit rules for 11, 12, 6, 7, 5, 9, 8, 4, 3."""
    digs = [0] + [int(c) for c in str(n)]      # zero in front
    out, carry, last = [], 0, len(digs) - 1
    for i in range(last, -1, -1):
        a = digs[i]; nb = digs[i + 1] if i < last else 0
        if m == 11: v = a + nb
        elif m == 12: v = 2 * a + nb
        elif m == 6: v = a + odd5(a) + half(nb)
        elif m == 7: v = 2 * a + odd5(a) + half(nb)
        elif m == 5: v = half(nb) + odd5(a)
        elif i == 0:                            # last step, under the zero
            v = {9: digs[1] - 1, 8: digs[1] - 2,
                 4: half(digs[1]) - 1, 3: half(digs[1]) - 2}[m]
        else:
            c = 10 - a if i == last else 9 - a  # first step or middle steps
            add = 0 if i == last else nb
            v = {9: c + add, 8: 2 * c + add,
                 4: c + odd5(a) + (0 if i == last else half(nb)),
                 3: 2 * c + odd5(a) + (0 if i == last else half(nb))}[m]
        t = v + carry; out.append(t % 10); carry = t // 10
    res = int("".join(map(str, out[::-1])))
    assert res == n * m, (n, m, res)
    return res

def two_finger(a, b):
    A = [int(c) for c in str(a)][::-1]; B = [int(c) for c in str(b)][::-1]
    out, carry = [], 0
    for k in range(len(A) + len(B)):
        s = 0
        for j, bj in enumerate(B):
            i = k - j
            if 0 <= i < len(A): s += U(A[i] * bj)           # units of the number
            if 0 <= i - 1 < len(A): s += T(A[i - 1] * bj)   # tens of the neighbour
        t = s + carry; out.append(t % 10); carry = t // 10
    res = int("".join(map(str, out[::-1])))
    assert res == a * b
    return res

def fast_divide(digits, divisor, trial):
    """Fast division for a two-digit divisor; trial = first digit, or first digit + 1."""
    d1, d2 = divmod(divisor, 10)
    P, idx = (digits[0], 1) if digits[0] >= trial else (digits[0] * 10 + digits[1], 2)
    q = []
    while idx < len(digits):
        x = P // trial
        while True:
            NT = d1 * x + T(d2 * x)
            if NT > P: x -= 1; continue                     # too large
            Pn = (P - NT) * 10 + digits[idx] - U(d2 * x)
            if Pn < 0: x -= 1; continue                     # too large
            if Pn >= divisor: x += 1; continue              # too small
            break
        q.append(x); P = Pn; idx += 1
    return q, P

for m in (11, 12, 5, 6, 7, 8, 9, 4, 3):
    print(386, "x", m, "=", single(386, m))
print(7429 * 11 == single(7429, 11), 7429 * 6 == single(7429, 6))
for a, b in ((98, 97), (47, 53), (386, 524)):
    print(a, "x", b, "=", two_finger(a, b))
print(fast_divide([7, 4, 2, 9], 37, 3))           # ([2, 0, 0], 29)
q, _ = fast_divide([1] + [0] * 19, 19, 2)
print("1/19 = 0.0" + "".join(map(str, q)))      # 0.0526315789473684210...
print(88 * 88, 85 * 85)                         # 7744 7225

The simulator used to build the tables in this post adds printing of each step and the step counters; the logic is the same.

Common mistakes

• Forgetting the zero in front. Without it, people stop one step early and lose the leftmost digit, especially with 11 and 12, where the last step is "0 plus the neighbour".
• Taking a true half. The rules need the simplified half: half of 7 is 3, not 3.5. The fraction is already accounted for by the "plus 5 if odd" part.
• Checking the neighbour's oddness. Only the number's oddness adds 5.
• Using "subtract from 10" more than once. In the rules for 9 and 8, only the rightmost digit is subtracted from 10. Every other digit is subtracted from 9.
• Panicking at a negative last step. With 3, the last step can be −1 before the carry is added. The carry always fixes it.
• Losing the tens with the two-finger method. Units go with the left digit of the pair and tens with the right digit. Swapping them gives nonsense that can still look plausible.
• Counting to 10 instead of 11 in addition. It still gives the right total, but you lose the column-by-column check, which is the reason for the rule.
• Skipping the trouble-saving device. For divisors like 19, 29 or 39, dividing by the first digit gives a wrong first guess almost every time. Divide by the first digit plus one.
• Repeating the foreword as history. The camp years and the death date in popular accounts do not match the archives.

FAQ

What is the Trachtenberg speed system?

A system of mental arithmetic developed by Jakow Trachtenberg, published in Zurich in German from 1946 and in English in 1960. It replaces the multiplication table with digit-by-digit rules based on each digit and its right-hand neighbour, and adds methods for long multiplication, addition, division, squares and square roots, each with a built-in check.

How do you multiply by 11 using the Trachtenberg method?

Put a zero in front of the number. Working from the right, write the last digit, then add each digit to its neighbour on the right, carrying as usual. The last step is the zero plus the first digit. For 386 x 11: 6, then 8 + 6 = 14 (write 4, carry 1), then 3 + 8 + 1 = 12 (write 2, carry 1), then 0 + 3 + 1 = 4. The answer is 4,246.

How do you multiply by 12 with the Trachtenberg system?

Double each digit and add its neighbour. For 386 x 12 the steps give 12, 23, 16 and 4, which write as 4,632.

Can the Trachtenberg system multiply any two numbers?

Yes. The direct method sums outside and inside pairs of digit products, and the two-finger method sums units and tens of those products, so any multiplicand and any multiplier can be handled without writing partial products.

Is the Trachtenberg system faster than normal multiplication?

There is no published controlled study that shows it. By our count it uses the same digit products as the school method and avoids writing intermediate rows. Its main gain is in memory load: smaller running totals and carries. Measure your own times before and after practice.

Was Trachtenberg really in a concentration camp?

He was persecuted, registered by the Vienna Gestapo in 1940, interned in camps in Yugoslavia and arrested again in 1944, according to archival research published in 2023. The same research found he was not held in Sachsenhausen or Auschwitz, as some retellings say, and that the period from 1940 to 1945 still needs research.

When did Jakow Trachtenberg die?

A Swiss Federal Archives death notice, published by historian Igor Petrov, records his death in Zurich on 26 October 1951. Many popular sources give 1953.

Is the Trachtenberg system the same as Vedic maths?

No, but they overlap. The Trachtenberg direct method and the Vedic crosswise method compute the same sums in the same order, and both square numbers ending in 5 the same way. Trachtenberg has no near-base rule like Nikhilam, and the Vedic book has no equivalent of the single-digit neighbour rules or the eleven-based addition check.

Deep dives

The mathematics traditions series works the same problems in other systems:

• Indian and Vedic Mathematics Explained: the 16 Sutras, Śulba Sūtras, Zero, Āryabhaṭa, Brahmagupta and the Kerala School
• Chinese Mathematics Explained: Counting Rods, the Nine Chapters, Fangcheng, the Remainder Theorem and Horner before Horner
• Japanese Mathematics Explained: the Soroban, Anzan, Wasan, Seki Takakazu and Sangaku Temple Geometry
• Vedic vs Chinese vs Japanese Math: Same Problems, Three Systems

Checks you can repeat: an honest bridge

Safeguard does not do mathematics, and nothing in this post was computed by a Safeguard model. The parallel with our work is Trachtenberg's obsession with checking. His addition method keeps a second, cheaper record (the ticks) that must agree with the first, and when they disagree it points to the exact column at fault. That is the same idea as the checksums and signed provenance that let you confirm a package or container image is the one that was built, and find the step where it changed. If you build a practice app, a classroom quiz or a notebook like the one above, it runs on open source dependencies, and those deserve the same habit: a check at every step, and a fast fix when a check fails.

More in this series

Other posts in our fast calculation methods series:

• Babylonian Mathematics Explained: Base 60, YBC 7289 and Plimpton 322
• Chisanbop Explained: Korean Finger Math to 99, With Worked Examples
• Egyptian and Russian Peasant Multiplication: Doubling and Binary
• Fastest Mental Math Methods Compared: 14 Systems, Same 7 Problems
• Lattice Multiplication, Napier's Bones and the Slide Rule Explained
• Line Multiplication: The Stick Method, Japanese, Chinese or Neither?
• Maya Mathematics Explained: Base 20, Bar and Dot Numerals and Zero
• Mental Calculation Techniques of World Champions: Left to Right, Criss-Cross, Squares and Calendars

Fix it without waiting for upstream

Whatever the vulnerability, most of the risk sits in two gaps. The first is the time between a fix being published and that fix actually running in your production builds. The second, and worse, is the time before any fix exists at all, while a maintainer works out a patch and a release schedule. Waiting through both gaps is a habit, not a requirement. Safeguard gives teams three ways to close them.

1. Autonomous remediation: pull requests, not tickets

When a fixed version exists, Safeguard's Griffin models open a tested, policy gated pull request that moves the affected dependency to the safe version. You can run it on one repository or in bulk across every project that carries the vulnerable version. Remediation covers eight categories, including dependencies, licenses, security posture and findings. Reachability analysis ranks the vulnerable code paths your application actually calls first, so the first pull requests you merge are the ones that matter most. Autonomous remediation ships switched off, with every category set to Manual, so your team decides how much runs on its own and what still needs a human approval.

2. Gold Open Source: the safe version in seconds, free

gold.safeguard.sh is free and needs no login. Search any CVE or package to see affected and fixed versions, CVSS, EPSS, CISA KEV status and a recommended safe version, or use the "Am I affected?" checker. The same data is available through a free read API, README status badges and RSS threat feeds. The safeguard-sh/gold-scan-action GitHub Action can fail a build on a known exploited vulnerability, on any known vulnerability, or never, so a version you have just removed cannot quietly come back in next week's merge.

3. Gold Registry: start from components that are already fixed

registry.safeguard.sh provides hardened, drop in replacements for upstream packages and container images. Every Gold artifact is held continuously to zero exploitable critical or high CVEs, zero malware and a completed license check, with SLSA L3 or higher provenance, a Sigstore signature and a public evidence page you can hand to an auditor. An artifact loses its Gold badge if it regresses. Teams can point their own package directory at the registry so hardened equivalents resolve without changing how developers install anything.

When upstream has no fix yet, or will not ship one, Safeguard first works to get the fix accepted upstream. If the issue is severe or upstream will not move, Safeguard builds a fork, fixes the vulnerability there and publishes a hardened Gold build, so you are not stuck on a maintainer's release schedule. You can also request a hardened, compatibility tested build of a specific package. This fork and patch flow is in early access today, so ask which packages it covers before you plan around it.

One honest limit: when the vulnerable code lives in a vendor appliance, a hosted service or an operating system runtime you do not build yourself, the fix still has to come from that vendor or distribution. The steps above apply to the open source dependencies and container images you build and ship, which is where most teams carry the largest and least tracked share of their exposure.

See how Safeguard would help

None of these demos involve any arithmetic. They show the software side described in the bridge above.

The first demo is a real Safeguard CLI session. It installs the CLI, opens the interactive terminal and asks it to fix a lodash CVE in a repository. It reads the finding and the advisory, asks before any command that changes something, edits package.json to lodash 4.17.21, runs npm install and npm test with approval, prints a summary and pushes nothing. The same flow applies to a web app for mental arithmetic drills: scan the repository, then let the assistant propose the dependency upgrade under your approval.

Click through it at your own pace, or open it full screen.

The second demo sets up the Safeguard runner on your own machine, approves it with its device code and then scans from the terminal. That suits teachers and hobbyists who keep scripts like the walkthrough above on their own laptops and want the scan to run where the code lives.

Click through it at your own pace, or open it full screen.

The third demo connects Claude to the Safeguard MCP server with OAuth and lets you choose which tools Claude can use. If you already use Claude while building a practice app, it brings dependency findings into the same conversation, limited to the tools you allow.

Click through it at your own pace, or open it full screen.

To try it on your own repositories, download Safeguard and follow the CLI documentation.

Quick check

Sources

• Jakow Trachtenberg, The Trachtenberg Speed System of Basic Mathematics, translated and adapted by Ann Cutler and Rudolph McShane (Doubleday, 1960), catalogue record at the Internet Archive
• Igor Petrov, "Вычисляя Трахтенберга" (Calculating Trachtenberg), Radio Svoboda, 2 July 2023
• Deutsche Nationalbibliothek catalogue, works by Jakow Trachtenberg (SRU query)
• Documentation Centre of Austrian Resistance (DÖW)
• Library of Congress Catalog, LCCN 60-13513
• Wikipedia, Jakow Trachtenberg (checked for the inconsistent death year)
• ERIC, Institute of Education Sciences (search for "Trachtenberg system")
• Mental Calculation World Cup, overview of events
• Mental Calculation World Cup 2024, Paderborn, results
• D. Barner, G. Alvarez, J. Sullivan, N. Brooks, M. Srinivasan and M. C. Frank, Learning Mathematics in a Visuospatial Format: A Randomized, Controlled Trial of Mental Abacus Instruction, Child Development 87(4), 2016
• Open Library, editions of The Trachtenberg Speed System of Basic Mathematics

Last reviewed: 25 October 2026.