The Math of Antiquity: How to Perform Arithmetic Operations in Roman Numerals

1. Positional vs. Additive Mathematical Paradigms

To a modern student trained on the Indo-Arabic numeral system, mathematics is inextricably linked with positional notation. In a place-value system, the digit 5 represents five, fifty, or five hundred depending entirely on its alignment relative to the decimal point and other numerals. This elegant structure relies on the concept of zero as a placeholder, allowing column-based algorithms for basic arithmetic.

Ancient Roman mathematicians operated under a completely different paradigm. Roman numerals constitute a non-positional, additive system. There is no symbol for zero because there is no place-value column to keep empty. The characters I, V, X, L, C, D, and M represent absolute values (1, 5, 10, 50, 100, 500, and 1,000, respectively), and they are combined to represent numbers. While their arrangement typically runs from largest to smallest, the symbols do not scale by powers of ten depending on their position.

Consequently, standard column-based arithmetic (such as lining up digits vertically and carrying overflows to the next column) is impossible. Instead, Roman arithmetic is a structured discipline of string manipulation. To calculate, one must perform a sequence of symbolic actions: expanding subtractive abbreviations, concatenating strings, sorting characters, and reducing groupings into higher-order symbols.

2. The Core Algorithmic Pipeline of Roman Math

Before performing any mathematical operation, we must establish a consistent symbolic pipeline. Standard Roman numerals employ subtractive notation to shorten strings (writing IV instead of IIII, or XC instead of LXXXX). While subtractive shorthand is efficient for writing and engraving, it introduces logical exceptions that break direct character manipulation.

To bypass this, any Roman numeral arithmetic operation must first convert standard Roman numerals into their purely additive equivalents. The arithmetic pipeline consists of five key phases:

• Expansion: Convert all subtractive pairs (IV, IX, XL, XC, CD, CM) into their additive equivalents (IIII, VIIII, XXXX, LXXXX, CCCC, DCCCC).
• Concatenation: Combine the operand strings into a single, unified string.
• Sorting: Sort the combined string so that all characters appear in descending order of value (M > D > C > L > X > V > I).
• Reduction (Simplification): Scan the sorted string from right to left, replacing multiple smaller characters with their single larger equivalent (e.g., five I's become one V, two V's become one X, and so on).
• Restoration (Formatting): Apply standard subtractive shorthand rules to the final reduced string to return the value to its standard representation.

3. Deep Logic of Addition: Cascade Reductions

Let us analyze addition in Roman numerals. In an additive system, addition is logically equivalent to string concatenation followed by alphabetical reorganization and symbol replacement. Let us trace the addition of CLXXXVI (186) and XCVII (97).

Phase 1: Expansion
First, expand subtractive pairs: CLXXXVI (186) remains unchanged, while XCVII (97) contains XC (90), which expands to LXXXX. The second operand becomes LXXXXVII.

Phase 2: Concatenation and Sorting
We merge the two expanded strings together and sort the symbols from largest to smallest value:
CLXXXVI + LXXXXVII $ ightarrow$ CLXXXVILXXXXVII $ ightarrow$ C L L XXXXXXX V V III.

Phase 3: Reduction
We simplify the sorted string by scanning from right to left (from smallest values to largest values) and applying carrying rules:

• I's: III remains III.
• V's: V V becomes X, changing our string to C L L XXXXXXXX III.
• X's: Eight Xs reduce to one L and three Xs (C L L L XXX III).
• L's: Three Ls reduce to one C and one L (C C L XXX III).
• C's: CC remains unchanged.

The simplified string is CCLXVIII. We check for any sequences of four identical characters or subtractive opportunities. There are none. The final result is CCLXVIII (283).

4. Deep Logic of Subtraction: The Borrowing Paradigm

Subtraction in Roman numerals requires symbol cancellation and borrowing. Instead of merging strings, we eliminate matching characters from the minuend (the number being subtracted from) and the subtrahend (the number being subtracted). If the minuend lacks the necessary characters, we borrow by expanding a larger symbol into its smaller components. Let us compute CCXXIV (224) minus LXXVIII (78).

Phase 1: Expansion and Cancellation
Expand subtractive terms: the minuend CCXXIV becomes CCXXIIII, and the subtrahend remains LXXVIII. Cancel matching symbols (two Xs and three Is) from both sides. This leaves Minuend: C C I and Subtrahend: L V.

Phase 2: The Borrowing Cycle
We cannot cancel L (50) or V (5) from C C I directly because the minuend only contains hundreds (C) and ones (I). We must borrow by expanding one of the hundred symbols (C):

1. Borrow from C: decompose one C to L L, yielding Minuend: C L L I. Cancel L, leaving Minuend: C L I and Subtrahend: V.
2. Borrow from L: decompose L into XXXXX, yielding Minuend: C XXXXX I.
3. Borrow from X: decompose one X into V V, yielding Minuend: C XXXX V V I.
4. Cancel V: remove the matching V from both sides, leaving Minuend: C XXXX V I. Subtrahend is empty.

The remaining symbols in the minuend are C XXXX V I. We sort them: CXXXXVI. Finally, we restore subtractive formatting: the four Xs (XXXX) are rewritten as XL (40). The final result is CXLVI (146).

5. Deep Logic of Multiplication: Duplation and Mediation

For multiplication, the lack of positional notation makes the modern grid method unusable. Historically, calculators utilized a binary-like method known as duplation and mediation (often referred to as Egyptian or peasant multiplication). This method reduces any multiplication problem to a series of doublings, halvings, and additions, requiring no knowledge of multiplication tables beyond the number 2.

Let us multiply XII (12) by XIII (13). We construct a table with two columns. The left column (Column A) undergoes mediation (halving, discarding fractions), and the right column (Column B) undergoes duplation (doubling).

• Halving (Mediation): Halving XII (12) successively gives VI (6), III (3), and I (1), discarding remainders. Sequence: 12 $ ightarrow$ 6 $ ightarrow$ 3 $ ightarrow$ 1.
• Doubling (Duplation):
  • Double XIII (13) $ ightarrow$ XXVI (26)
  • Double XXVI (26) $ ightarrow$ LII (52)
  • Double LII (52) $ ightarrow$ CIV (104)

According to the algorithm, we cross out the rows where Column A has an even number:

1. Row 1: Column A is XII (12, even). Strike out XIII (13).
2. Row 2: Column A is VI (6, even). Strike out XXVI (26).
3. Row 3: Column A is III (3, odd). Keep LII (52).
4. Row 4: Column A is I (1, odd). Keep CIV (104).

We add the kept numbers from Column B: LII + CIV. We expand CIV to CIIII, concatenate them to get LIICIIII, sort them to C L IIIIII, and reduce to C L V I $ ightarrow$ CLVI (156). Thus, $12 imes 13 = 156$.

6. Deep Logic of Division: Scaling and Partial Quotients

Division is the most computationally demanding operation in Roman mathematics. Without place values, long division is impossible. Instead, Roman accountants used the partial quotients method, which involves scaling the divisor and repeatedly subtracting it from the dividend. Let us divide LXXIII (73) by IX (9).

Phase 1: Expansion and Scaling
Expand Dividend to LXXIII and Divisor to VIIII. We scale the divisor by convenient factors to reduce subtraction steps:

• $10 imes$ Divisor: 90 (LXXXX) exceeds our dividend 73 (cannot use).
• $5 imes$ Divisor: 45 (XXXXV) is less than 73 (can subtract).

Phase 2: Repeated Subtraction and Tallying

• Subtract $5 imes$ Divisor (XXXXV): Dividend LXXIII is expanded to XXXXXX VV III. Subtracting XXXXV leaves XXVIII (28). Quotient tally: V (5).
• Subtract $2 imes$ Divisor (XVIII): Subtracting XVIII from XXVIII leaves X (10). Quotient tally: V + II = VII (7).
• Subtract $1 imes$ Divisor (VIIII): Expanding X to V IIIII and subtracting VIIII leaves I (1). Quotient tally: VII + I = VIII (8).

The remaining dividend is I (1), which is less than the divisor VIIII (9). Therefore, our division is complete: Quotient: VIII (8), Remainder: I (1).

7. The Physical Engine: The Roman Abacus (Calculi)

While string-based algorithms demonstrate the mathematical completeness of Roman numerals, historical evidence suggests that Roman merchants and accountants rarely performed these lengthy pencil-and-paper (or stylus-and-wax) computations. Instead, they performed calculations mechanically using a physical Roman abacus (or calculating board) with sliding tokens called calculi.

The Roman abacus was structured with vertical grooves representing decimal columns. Within each groove, the board was split into two chambers:

• The lower chamber contained four counters, each representing 1 unit of that column's power of ten.
• The upper chamber contained a single counter, representing 5 units of that column's power of ten.

This physical layout corresponds exactly to the additive-subtractive rules of Roman numerals. Sliding five beads up in the lower chamber and replacing them with one bead in the upper chamber is the exact mechanical equivalent of the reduction rule IIIII $ ightarrow$ V. Physical computation on the abacus bypasses string manipulation entirely, providing a fast, visual, and highly reliable calculation engine.

8. Comparison of Roman Arithmetic Operations

9. Modern Computational Implementation and Data Privacy

Performing multi-step Roman numeral conversions and arithmetic modeling requires robust software engineering. Our application employs a client-side conversion architecture that prioritizes user data privacy.

By executing tokenization, expansion, and reduction in the browser, the application adheres to **Zero Server Logging (ZSS)** principles. No inputs, equations, or histories are transmitted to external databases. This local model eliminates latency and prevents the exposure of sensitive calculations, ensuring complete data sovereignty.