Full adder

Definition

A full adder is a combinational logic circuit that adds three 1-bit binary inputs—usually labeled A, B, and Cin (carry-in)—and generates two outputs: Sum and Cout (carry-out).

The logical function of a full adder can be written as:

Sum = A ⊕ B ⊕ Cin

Cout = AB + Cin(A ⊕ B)

Here, ⊕ denotes the XOR operation, and + denotes OR in Boolean algebra.

A full adder is the basic building block for constructing ripple carry adders, carry look-ahead adders, and other binary arithmetic circuits.

Main Content

1. Inputs and Outputs of a Full Adder

A full adder has three inputs:
A: first binary operand bit
B: second binary operand bit
Cin: carry-in from the previous lower bit position
It has two outputs:
Sum: the least significant result bit of the current stage
Cout: carry-out sent to the next higher bit stage

A full adder must consider all possible combinations of the three input bits. Since each input can be either 0 or 1, there are 8 possible input cases:

A	B	Cin	Sum	Cout
0	0	0	0	0
0	0	1	1	0
0	1	0	1	0
0	1	1	0	1
1	0	0	1	0
1	0	1	0	1
1	1	0	0	1
1	1	1	1	1

This truth table shows that the sum output behaves like binary addition modulo 2, while the carry-out indicates whether the addition result exceeds one bit.

2. Boolean Expressions and Logic Implementation

The sum output is obtained using XOR gates:
First, A ⊕ B
Then, XOR the result with Cin
Final expression: Sum = A ⊕ B ⊕ Cin
The carry-out can be expressed in two common ways:
Cout = AB + Cin(A ⊕ B)
Equivalent form: Cout = AB + ACin + BCin

The second expression shows that carry occurs when:

both A and B are 1, or
one of A/B is 1 and Cin is 1

A practical gate-level design often uses:

2 XOR gates

for sum

2 AND gates and 1 OR gate

for carry, or
a combination of XOR, AND, and OR gates depending on optimization

Example: If A = 1, B = 1, Cin = 0

Sum = 1 ⊕ 1 ⊕ 0 = 0
Cout = 1·1 + 0(1 ⊕ 1) = 1
So the output is Sum = 0, Carry = 1, which represents binary 2.

3. Construction from Half Adders

A full adder can be built using two half adders and one OR gate
This is a very common conceptual and practical method
The process is:
First half adder adds A and B
Second half adder adds the first sum and Cin
OR gate combines the two carry outputs

A simple arrangement:

A ──┐
    ├── Half Adder ── S1 ──┐
B ──┘                     ├── Half Adder ── Sum
Cin ──────────────────────┘

Carry1 ──┐
         ├── OR ── Cout
Carry2 ──┘

Explanation:

First half adder

Sum = A ⊕ B
Carry1 = A·B

Second half adder

Sum = (A ⊕ B) ⊕ Cin
Carry2 = Cin·(A ⊕ B)
Final carry:
Cout = Carry1 + Carry2

This method helps students understand how the full adder works internally and is frequently used in textbooks and basic digital design courses.

Working / Process

1. Accept three binary inputs

The full adder receives inputs A, B, and Cin.
These represent two bits being added and the carry from the previous stage.

2. Generate the sum bit

The circuit first determines whether the total number of 1s among the inputs is odd or even.
XOR logic is used because it outputs 1 when an odd number of inputs are 1.
Hence, the sum bit is formed as:
- Sum = A ⊕ B ⊕ Cin

3. Generate the carry-out bit

If two or more of the inputs are 1, the circuit must produce a carry.
The logic detects these conditions using AND and OR operations.
Final carry is:
- Cout = AB + ACin + BCin
This carry is then passed to the next full adder stage in multi-bit addition.

Example of operation: Add three bits: A = 1, B = 0, Cin = 1

Sum = 1 ⊕ 0 ⊕ 1 = 0
Cout = (1·0) + (1·1) + (0·1) = 1
So the result is 10 in binary, which is decimal 2.

Multi-bit use case: When adding binary numbers like:

  1011
+ 0110

the least significant bit is handled by one adder stage, and each carry is transferred to the next stage. This creates a chain of full adders, commonly called a ripple carry adder.

Advantages / Applications

Can add three bits directly

Unlike a half adder, it includes carry-in, which is necessary for real multi-bit arithmetic.

Essential building block for arithmetic circuits

Full adders are used to construct larger adders such as ripple carry adders, carry select adders, and carry look-ahead adders.

Widely used in digital systems

They are used in CPUs, ALUs, calculators, digital meters, and embedded systems for binary addition and arithmetic processing.

Supports cascading for larger numbers

Multiple full adders can be connected in series to add binary numbers of 4 bits, 8 bits, 16 bits, or more.

Simple and reliable design

The logic is straightforward, making it easy to implement in hardware and to analyze in academic studies.

Useful in subtraction and other arithmetic operations

Through two’s complement techniques, full adder circuits also help perform subtraction, incrementing, and comparison tasks.

Summary

A full adder adds three 1-bit binary inputs and produces sum and carry-out
It is the basic circuit used for multi-bit binary addition
The main logic is based on XOR, AND, and OR operations
Important terms to remember: Sum, Carry-in, Carry-out, XOR, Half Adder, Ripple Carry Adder