4-bit decrementer: subtract 1 with half subtractors, live

A 4-bit decrementer subtracts 1 from a 4-bit number: D = A - 1, with a borrow out when A is 0000, which wraps to 1111. It needs no B input, so instead of full subtractors it is a chain of four half subtractors, the first taking the constant 1 from A0 and each passing its borrow to the next.

Counting down is the mirror image of counting up. A down counter computes A - 1 as its next state, a loop counter in a program is decremented until it reaches zero, and a stack pointer is decremented on every push in many CPUs. Because the second operand is the constant 0001, each column subtracts only two bits, the borrow from below from A_i, which is exactly a half subtractor: D_i = A_i XOR B_i and the borrow out is NOT A_i AND B_i. The pattern is easy to read off: the decrementer flips every bit up to and including the lowest 1, so 1000 becomes 0111. The borrow keeps rippling through the 0 bits and stops at the first 1. If every bit is 0 there is no 1 to stop it, so 0000 - 1 gives 1111 with a borrow out, the same answer as -1 in two's complement. The half subtractors here are the verified half subtractor, saved as a part. All 16 inputs are checked before the page is built; the live circuit starts at 1000, so the borrow ripples through all four stages and D shows 0111.

Live circuit: click the inputs to toggle them and watch the outputs update. It runs the real simulator, right here on the page.

Open this circuit in the lab →

Embed or cite this circuit

Free to embed on a course page, blog or worksheet: paste this code. The circuit stays live, and the small digiwleea badge links back here.

<iframe src="https://digiwleea.wleeaf.dev/embed/?c=H4sIAAAAAAAAA-2aTW_bRhCG_0qxZwbgfnBJ6ubACFqgSIB-AAUCH2SJcYnKpEFRcYLA_70QxSVnNDNcxXbRHnpKQu0zO7s7O_NymG_qU9vdr3u1Utv6rn7cVdX6zabuNoe6V4n6XHX7um3USieqWd9Xx2HVpqvuq6avujfudhjVVF_6n7Zq5fJE1c2-Xzebaq9WH7-peqtWaqNVov6qm-Pf6-bhcETarr6rG7X6pr6olbOJ-qpW-ilRXduv-2HGNFG79W21Uyt1ZY-urHeHahgUzJqIWVMOZr1o1sxm09msjZjV2clbI9rVrF0Xs3sy60SzKWs2m81-3mzIHpyMltjoTPuZ_nNPPBpdyiU6X6LNuE9aoosl2pYRulyiMxuhdTrjD117W51b8HnklK-tAuZ0xNzokBiL1wZaMxFrNhLZ1xpasxFr40EZeakpNOcu3LlcMve2PfTq6SZRj3UH88SjPsbyOuzYyUr2lKjb8VEeHk3ePGoPkFxESojkFCkBEqIeMQVgTkdpNGDGRxYiJUUsnQYxJgWMLqlvxlDfjAaQMSKEZzIUQu6FoECQZdxjII0gRyE8E7cRMBLmAQTSOYQ8hYYoPHcPQTAarKVrsp5ZEwoHL0JoopIy0LnxTkPEptQ3hGQUgcEw_U4QnULGUEanEMoZCMbCPIBCcN-sYyBLNwFDGXNCzM6hY7UwFhwzk-NmgrHgmPh2zBkVlIHOZZYiJfXNQCQdH82Ig5Ew_U4QtBqnKYNWk1kGMsy-MetBm-1gLHhNZ_JMLDjHQHAmz80EY8EzsRCeFRDyDFQw7hVPx6q0r--a9e5Ul0bNCwXoICLC83MFGZ6fK8DwHEm4m0Rt2vuHtqmaHk036JlQLX-8-vndD7_-_lYlat8euk11dPp7RftgMch0Y58n009nVIr6lJWnMZHOS0wgFmIa_UvbCbq1kMQfUDBNSz3S3NsIK7jXzVZSveYCxb2kxsQNuQZaLL9MJw6K6PukWEGVWMpoJFgRSooUVInBi6lTqsQYxEFEU8QxjiHGMLLFMGICZlxtGTHBQGg9jjIF1R8IYSRvSrcA7jMneSmCpChVvIwSRURBtwzJL0MReP7T71S6wpNBenceQBUbgvRyoJmMRhqSu0FDeEZDeLEE8Bkdpaebp0Q91M2Hblt1avVxYI4Dro9_Hm_aTaIOD9t1X22v-iH1bbpq-hewespp4ZL-8eGXFyX_Q9PX_a7awk7NM0uA4xLrS0uAizQ-oiWAz31m2dd3ii8ITE7X6XzLYiWB48MLzAUlYQHXYj3LL-PP3Y-k_WIq9-GSlOMTPueXwnicVlNCoKwattpIOf_EuEWvUMKnwLgfTsr2BW0jTHVUSPYlTV0cki0jYfFOyval5JlJpXQ__U5fuFMx4RfMwXCHWdIq4SljjJTyGWZ0zksJf7ZJF2SkjG9oENiUBAFqb0y_EwT1XhxFUOuFQVBrQ0TQRuPORkpPh1MwqLNhmDgY_UVxgDsbqQhpubUxDaBrEpsbZgGCR4TaG_MAuhEIYkIB7Z5ldg_3Nxj9ZzU5Wtze0ORox5KEEBgN4f77SE6wTKOrWL5DqLUR7guzcegOod5G2FnmsmLnSiaToCxX0N1G_Q3DZIVwgYX2huGyApMaHRcKjkJH516mA_df72_b3aTlLpJ9Y_EOCuX91fvr1xZ-x_X9L_w44cd8PAu15gLZ93Df0s9nborjaCeAwcf3IYzrQtB93PwFu7_sB7gF_vy7EPsJ7o6RnafMZS-QnUgV6pwqNksVm6YIyps5RdDltzTJMLNYOgsuvJaRRUwbgK3WTtKGs0JbTtCaKQSGqQRWlIdU5I9RK3790oYihpZ3rA2nAbQM5JI4ZGR4KIaZqA5TETKZpA7nAcQ7DNnLZsokgTj9Dg7IUwRFgpeQUtSHlok4puZifchIflPQiQrK8ArnlarnWBIvK59DL3eqnh9-e-3iqZ_7_1teWDxfXObscpkrlsuci5Q5v1zmskiV8bOujJVJpsoE58-LHFNlYLxr-kY4vYzO4c50QdmXYsgw78SGYQxK_qj-OXKtxkf4vyToCEPTBG6ETzYJg-ehrZFYuWC--GOR7WP1z4tQKZY__7JshNPOkEouyjpYs_8Dkv3fyjr_fcnO9mo51SxkI_rtj9XcbDLxy7eC9n1yKgQYopCyTzrt0JnqKoTcw8knTeUTTj1ahlIx94D28rkiTEX5Tddj6Ho005GDCNOR05GOHNODQakneG5iq-FackivTwf6SlIoqoRunv4GTtoOw84rAAA" width="100%" height="420" style="border:0;border-radius:12px;max-width:640px" title="4-bit decrementer circuit (digiwleea)" loading="lazy"></iframe>

To cite it: digiwleea, “4-bit decrementer”, https://digiwleea.wleeaf.dev/tools/build/decrementer-4bit/

What you need

4× half subtractor: one per bit: Di = Ai XOR Bi, borrow out = NOT Ai AND Bi
1× constant 1: the B input of the first half subtractor

Step by step

Place inputs A3 to A0 and probes D3 to D0 and Bout.
Feed A0 and a constant 1 into the first half subtractor; its difference is D0 (NOT A0).
Feed each next bit Ai and the borrow from the half subtractor below into the next half subtractor; its difference is Di.
The last half subtractor's borrow is Bout, which is 1 only for 0000 - 1.
Count A down from 1111 to 0000: D is always one less, wrapping to 1111 with Bout = 1.

4-bit decrementer truth table

A3 A2 A1 A0	D3 D2 D1 D0	Bout	Decimal
0000	1111	1	0 - 1 wraps to 15 (borrow)
0001	0000	0	1 - 1 = 0
0010	0001	0	2 - 1 = 1
0011	0010	0	3 - 1 = 2
0100	0011	0	4 - 1 = 3
0101	0100	0	5 - 1 = 4
0110	0101	0	6 - 1 = 5
0111	0110	0	7 - 1 = 6
1000	0111	0	8 - 1 = 7
1001	1000	0	9 - 1 = 8
1010	1001	0	10 - 1 = 9
1011	1010	0	11 - 1 = 10
1100	1011	0	12 - 1 = 11
1101	1100	0	13 - 1 = 12
1110	1101	0	14 - 1 = 13
1111	1110	0	15 - 1 = 14

All 16 rows, with all five outputs each, are checked on the live circuit before the page is built. The 4-bit incrementer is the same idea with half adders and a carry chain: A + 1 flips every bit up to and including the lowest 0.

You can also read the full theory in the lesson on the half subtractor. Prefer to build it yourself from scratch? Open the digiwleea lab and place the gates on the canvas, or start from the logic gate simulator.

More builds: Arithmetic

4-bit incrementer 4-bit ripple carry adder 3-bit binary adder 4-bit carry lookahead adder 2-bit adder 4-bit carry lookahead generator Full subtractor using a decoder 4-bit carry-select adder Full adder using a decoder 4-bit carry-skip adder full adder using two half adders 4-bit Kogge-Stone adder

All 246 build guides, by topic

Each of these is one step from a transistor to a working CPU. Build every gate from CMOS transistors and work all the way up in the free digiwleea lab, with the free theory reference alongside.

Open the 4-bit decrementer in the lab →

Frequently asked

What is a 4-bit decrementer?

A combinational circuit that outputs its 4-bit input minus 1, with a borrow out when the input is 0000 (which wraps to 1111). Down counters and loop counters use it.

How do you design a decrementer circuit?

Chain half subtractors, one per bit. The first subtracts a constant 1 from A0, and each later stage subtracts the borrow from the stage below: Di = Ai XOR Bi and the next borrow is NOT Ai AND Bi.

Can you build a decrementer from adders?

Yes. Subtracting 1 is the same as adding 1111, the two's complement of 0001, and ignoring the carry out. A 4-bit adder with B = 1111 works, but it needs four full adders, while the half subtractor chain gets by with fewer gates.

How many gates does a 4-bit decrementer need?

Four half subtractors, each one XOR, one NOT and one AND, so twelve gates. The first stage subtracts a constant 1, so it reduces to D0 = NOT A0 and borrow = NOT A0, which a simplified design can use to save gates.

What is the difference between an incrementer and a decrementer?

An incrementer adds 1 with a carry chain and flips bits up to the lowest 0; a decrementer subtracts 1 with a borrow chain and flips bits up to the lowest 1. 1111 + 1 and 0000 - 1 are the two cases that wrap around.