Data & ComputingLogic Gates and Binary ArithmeticA-Level

Full Adder - Carry Out

This formula calculates the carry-out bit (C_out) for a full adder, which accounts for the overflow generated when adding three binary digits.

Understand the formulaSee the free derivationOpen the full walkthrough

C_{o u t} = (A \cdot B) \lor (C_{in} \cdot (A \oplus B))

Open Full Walkthrough Try Calculator

This public page keeps the free explanation visible and leaves premium worked solving, advanced walkthroughs, and saved study tools inside the app.

Core idea

Overview

The carry-out is produced if at least two of the three input bits (A, B, or C_in) are high. The formula uses the product of inputs and the XOR gate to identify conditions where bit summation exceeds the capacity of a single output bit, triggering a carry to the next significant position.

When to use: Use this when designing binary addition circuits or calculating the carry bit in a multi-bit ripple-carry adder.

Why it matters: This logic is the foundation of all arithmetic operations in modern CPUs, enabling the hardware to perform complex additions.

Symbols

Variables

A = Input A, B = Input B, Cin = Carry In

A

Input A

V a r iab l e

B

Input B

V a r iab l e

C in

Carry In

V a r iab l e

Walkthrough

Derivation

Derivation of Full Adder - Carry Out

The carry-out function is derived by identifying the input combinations that result in a carry in a full adder using Boolean logic and simplification.

The circuit is a standard binary full adder with inputs A, B, and $C_{i}$ n.
The logic gates follow standard Boolean algebra laws (AND, OR, XOR).

Construct Truth Table

Identify the output rows of a full adder truth table where $C_{o}$ ut is high (1). This occurs when at least two of the three inputs (A, B, $C_{i}$ n) are high.

C_{o u t} = \sum (3, 5, 6, 7)

Note: A full adder generates a carry if A and B are 1, OR if one of them is 1 and the carry-in is 1.

Sum of Products Expression

Write the Boolean expression by ORing all minterms where the result is 1.

C_{o u t} = (A \cdot B \cdot \overline{C_{in}}) \lor (A \cdot \overline{B} \cdot C_{in}) \lor (\overline{A} \cdot B \cdot C_{in}) \lor (A \cdot B \cdot C_{in})

Note: This is the unsimplified canonical form.

Boolean Simplification

Factor out common terms using the distributive law. By grouping (A · B · $C_{i}$ n) with the other terms, we simplify the expression to the XOR relationship of the inputs.

C_{o u t} = (A \cdot B) \lor (C_{in} \cdot (A \oplus B))

Note: Recognizing (A · B' + A' · B) as the XOR operator (A ⊕ B) is a common shortcut in A-Level computing.

Result

C_{o u t} = (A \cdot B) \lor (C_{in} \cdot (A \oplus B))

Source: A-Level Computer Science Specification - Logic Gates and Boolean Algebra

Why it behaves this way

Intuition

Think of a two-lane merging traffic scenario: The (A ⋅ B) term is a dedicated merging ramp that always triggers if both lanes have cars, while the ( $C_{i}$ n ⋅ (A ⊕ B)) term acts like a backup signal that triggers if there is a car coming from behind ( $C_{i}$ n) and exactly one of the two main lanes is occupied, pushing the overflow forward.

A, B

Input binary bits

The two primary binary digits being added together.

C_{in}

Carry-in bit

The 'overflow' or remainder passed over from the addition of the previous, less significant bit column.

C_{o u t}

Carry-out bit

The resulting overflow bit that must be passed to the next column if the sum of the inputs exceeds the capacity of a single binary digit.

Signs and relationships

⋅ (AND): Represents the strict condition where both inputs must be high (1) to generate a carry by default.
⊕ (XOR): Identifies when only one of the primary inputs is present; if a carry-in also exists, these two conditions combine to force a carry-out.
∨ (OR): Acts as a logical joiner, indicating that a carry-out is produced if the primary inputs overflow OR if the combination of the previous carry and one input forces an overflow.

One free problem

Practice Problem

Calculate the carry-out ( $C_{o}$ ut) if A=1, B=1, and $C_{i}$ n=0.

Input A1

Input B1

Carry In0

Solve for: $C o u t$

Hint: Since A and B are both 1, the product (A ⋅ B) evaluates to 1.

The full worked solution stays in the interactive walkthrough.

Where it shows up

Real-World Context

When a processor adds two 64-bit integers, it uses a chain of 64 full adders where each C_out serves as the C_in for the next bit.

Study smarter

Tips

Remember that (A ⊕ B) is equivalent to A XOR B.
Visualize the logic gates: you need two AND gates and one OR gate to implement this.
Recognize that this logic is part of the standard Full Adder block used in ALU design.

Avoid these traps

Common Mistakes

Confusing the Full Adder carry-out with the Half Adder carry-out.
Forgetting to include the carry-in bit when performing multi-bit additions.
Incorrectly prioritizing the OR operation over the product terms.

Common questions

Frequently Asked Questions

The carry-out function is derived by identifying the input combinations that result in a carry in a full adder using Boolean logic and simplification.

Use this when designing binary addition circuits or calculating the carry bit in a multi-bit ripple-carry adder.

This logic is the foundation of all arithmetic operations in modern CPUs, enabling the hardware to perform complex additions.

Confusing the Full Adder carry-out with the Half Adder carry-out. Forgetting to include the carry-in bit when performing multi-bit additions. Incorrectly prioritizing the OR operation over the product terms.

When a processor adds two 64-bit integers, it uses a chain of 64 full adders where each C_out serves as the C_in for the next bit.

Remember that (A ⊕ B) is equivalent to A XOR B. Visualize the logic gates: you need two AND gates and one OR gate to implement this. Recognize that this logic is part of the standard Full Adder block used in ALU design.

References

Sources

Mano, M. M., & Ciletti, M. D. (2017). Digital Design: With an Introduction to the Verilog HDL, VHDL, and SystemVerilog.
A-Level Computer Science Specification - Logic Gates and Boolean Algebra