About

Binary subtraction is the arithmetic foundation of every ALU (Arithmetic Logic Unit) in modern processors. Hardware does not subtract directly. It converts the subtrahend B into its two's complement and performs addition. Misunderstanding borrow propagation or sign handling leads to off-by-one errors in firmware, FPGA netlists, and low-level protocol implementations. This tool computes A − B for arbitrary-length unsigned binary strings using both the column-borrow method and the two's complement method, exposing every intermediate step. Results are cross-verified. The tool assumes unsigned interpretation. When B > A, the magnitude |A − B| is computed and flagged negative. Precision is limited only by browser string length, not by 32-bit or 64-bit word boundaries.

Formulas

Column subtraction at bit position i with borrow:

diff_i = A_i ⊕ B_i ⊕ borrow_i

borrow_i+1 = (¬A_i ∧ B_i) ∨ ((¬A_i ∨ B_i) ∧ borrow_i)

Two's complement method:

A − B = A + ¬B + 1

Where A is the minuend (first operand), B is the subtrahend (second operand), ⊕ is XOR, ¬ is bitwise NOT, and borrow_i is the incoming borrow at position i (LSB → MSB).

Reference Data

Bit A	Bit B	Borrow In	Difference	Borrow Out
0	0	0	0	0
0	0	1	1	1
0	1	0	1	1
0	1	1	0	1
1	0	0	1	0
1	0	1	0	0
1	1	0	0	0
1	1	1	1	1

Frequently Asked Questions

In addition, a carry occurs when the column sum exceeds 1 (i.e., 1 + 1 = 10). In subtraction, a borrow occurs when the minuend bit is smaller than the subtrahend bit plus the incoming borrow. The borrow propagates leftward, just like carry, but the logic gate equation differs: borrow uses ¬A ∧ B rather than A ∧ B. Chain borrows across multiple zero-bits are the most common source of manual calculation errors.

Direct subtraction requires a separate subtractor circuit with borrow logic. Two's complement reuses the existing adder by inverting B and adding 1. This halves the silicon area in the ALU. It also eliminates the problem of negative zero: in two's complement, there is exactly one representation for zero (00000000), whereas sign-magnitude has both +0 and −0.

The result is mathematically negative. Since unsigned binary cannot represent negative values, this tool computes the magnitude |A − B| by swapping the operands, performing the subtraction, and prefixing the result with a negative sign. In fixed-width hardware (e.g., 8-bit), this condition produces an underflow, wrapping around modulo 2ⁿ.

No. Leading zeros are stripped before computation. 00101 and 101 are treated identically as decimal 5. However, the step-by-step visualization pads both operands to equal length for clarity, so you will see leading zeros in the column breakdown.

Yes. The algorithm operates on JavaScript strings, not on native 32-bit or 64-bit integers. You can input binary strings hundreds of digits long. The only limit is browser memory for the string. BigInt is used solely for decimal conversion verification, not for the binary arithmetic itself.

JavaScript's native BigInt is used to parse the binary string via BigInt("0b" + binaryString). This supports arbitrary precision without floating-point rounding. The decimal, octal (base 8), and hexadecimal (base 16) representations are then derived from the BigInt value.