Boolean Algebra: Logic Gates, Truth Tables & Switching Algebra

This guide provides a comprehensive introduction to Boolean algebra – covering logic gates, truth tables, and switching algebra with practical examples.

In a Nutshell

Boolean algebra is the mathematics of logic with just two values: true (1) and false (0). It forms the foundation of all digital circuits and computers.

Quick Technical Overview

Boolean algebra is an algebraic system for describing logical operations. Developed by George Boole, it underpins all of digital electronics.

Basic Operations:

AND (Conjunction)

Symbol: ∧, ·, AND
Truth: True only when both inputs are true
Circuit: Series connection
Use: Safety functions, validation

OR (Disjunction)

Symbol: ∨, +, OR
Truth: True when at least one input is true
Circuit: Parallel connection
Use: Alternative decisions

NOT (Negation)

Symbol: ¬, ~, NOT, overline
Truth: Inverts the truth value
Circuit: Inverter
Use: Signal inversion

NAND (Not-AND)

Symbol: ↑, NAND
Truth: False only when both inputs are true
Circuit: AND with inverter
Use: Universal gate

NOR (Not-OR)

Symbol: ↓, NOR
Truth: True only when both inputs are false
Circuit: OR with inverter
Use: Universal gate

XOR (Exclusive-OR)

Symbol: ⊕, XOR
Truth: True when inputs differ
Circuit: Parity gate
Use: Error detection, cryptography

Key Study Points

Boolean algebra: Mathematics with two values (0 and 1)
Logic gates: Electronic circuits that perform logical operations
Truth tables: Systematic representation of all possible input combinations
Switching algebra: Application of Boolean algebra to circuits
Universal gates: NAND and NOR can replace all other gates
Karnaugh diagram: Simplification of logical expressions
Technical exam focus: Foundation for digital circuits and programming

Core Components

Boolean variables: Only 0 or 1
Logical operations: AND, OR, NOT, NAND, NOR, XOR
Truth tables: Complete function description
Switching algebra: Laws and simplifications
Logic gates: Electronic implementation
Circuit design: Combinatorial and sequential circuits
Minimization: Karnaugh maps, Quine-McCluskey
Applications: Computer architecture, digital systems

Practical Examples

1. Basic Logic Gates in Java

public class BoolescheAlgebra {
    
    public static void main(String[] args) {
        // Input values
        boolean a = true;   // 1
        boolean b = false;  // 0
        
        System.out.println("=== Basic Logical Operations ===");
        System.out.println("a = " + a + " (1), b = " + b + " (0)");
        
        // AND (Conjunction)
        boolean and = a && b;
        System.out.println("a AND b = " + and + " (" + (and ? 1 : 0) + ")");
        
        // OR (Disjunction)
        boolean or = a || b;
        System.out.println("a OR b = " + or + " (" + (or ? 1 : 0) + ")");
        
        // NOT (Negation)
        boolean notA = !a;
        boolean notB = !b;
        System.out.println("NOT a = " + notA + " (" + (notA ? 1 : 0) + ")");
        System.out.println("NOT b = " + notB + " (" + (notB ? 1 : 0) + ")");
        
        // NAND (Not-AND)
        boolean nand = !(a && b);
        System.out.println("a NAND b = " + nand + " (" + (nand ? 1 : 0) + ")");
        
        // NOR (Not-OR)
        boolean nor = !(a || b);
        System.out.println("a NOR b = " + nor + " (" + (nor ? 1 : 0) + ")");
        
        // XOR (Exclusive-OR)
        boolean xor = a ^ b;
        System.out.println("a XOR b = " + xor + " (" + (xor ? 1 : 0) + ")");
        
        // Truth tables
        truthTables();
        
        // Switching algebra laws
        switchingAlgebraLaws();
        
        // Practical applications
        practicalApplications();
    }
    
    private static void truthTables() {
        System.out.println("\n=== Truth Tables ===");
        
        System.out.println("A B | AND | OR | XOR | NAND | NOR");
        System.out.println("---+-----+----+-----+------+----");
        
        for (int a = 0; a <= 1; a++) {
            for (int b = 0; b <= 1; b++) {
                boolean aBool = a == 1;
                boolean bBool = b == 1;
                
                int and = (aBool && bBool) ? 1 : 0;
                int or = (aBool || bBool) ? 1 : 0;
                int xor = (aBool ^ bBool) ? 1 : 0;
                int nand = !(aBool && bBool) ? 1 : 0;
                int nor = !(aBool || bBool) ? 1 : 0;
                
                System.out.printf("%d %d |  %d  | %d  |  %d  |  %d   | %d%n", 
                                a, b, and, or, xor, nand, nor);
            }
        }
    }
    
    private static void switchingAlgebraLaws() {
        System.out.println("\n=== Switching Algebra Laws ===");
        
        boolean x = true;
        boolean y = false;
        boolean z = true;
        
        // Commutative laws
        System.out.println("Commutative laws:");
        System.out.println("x AND y = y AND x: " + ((x && y) == (y && x)));
        System.out.println("x OR y = y OR x: " + ((x || y) == (y || x)));
        
        // Associative laws
        System.out.println("\nAssociative laws:");
        System.out.println("(x AND y) AND z = x AND (y AND z): " + 
                          ((x && y) && z == x && (y && z)));
        System.out.println("(x OR y) OR z = x OR (y OR z): " + 
                          ((x || y) || z == x || (y || z)));
        
        // Distributive laws
        System.out.println("\nDistributive laws:");
        System.out.println("x AND (y OR z) = (x AND y) OR (x AND z): " + 
                          (x && (y || z) == (x && y) || (x && z)));
        System.out.println("x OR (y AND z) = (x OR y) AND (x OR z): " + 
                          (x || (y && z) == (x || y) && (x || z)));
        
        // De Morgan's laws
        System.out.println("\nDe Morgan's laws:");
        System.out.println("NOT (x AND y) = NOT x OR NOT y: " + 
                          (!(x && y) == (!x || !y)));
        System.out.println("NOT (x OR y) = NOT x AND NOT y: " + 
                          (!(x || y) == (!x && !y)));
        
        // Idempotence laws
        System.out.println("\nIdempotence laws:");
        System.out.println("x AND x = x: " + (x && x == x));
        System.out.println("x OR x = x: " + (x || x == x));
        
        // Null laws
        System.out.println("\nNull laws:");
        System.out.println("x AND 0 = 0: " + (x && false == false));
        System.out.println("x OR 1 = 1: " + (x || true == true));
        
        // Identity laws
        System.out.println("\nIdentity laws:");
        System.out.println("x AND 1 = x: " + (x && true == x));
        System.out.println("x OR 0 = x: " + (x || false == x));
        
        // Complement laws
        System.out.println("\nComplement laws:");
        System.out.println("x AND NOT x = 0: " + (x && !x == false));
        System.out.println("x OR NOT x = 1: " + (x || !x == true));
        System.out.println("NOT (NOT x) = x: " + (!(!x) == x));
    }
    
    private static void practicalApplications() {
        System.out.println("\n=== Practical Applications ===");
        
        // Security system: multiple conditions must be met
        boolean passwordCorrect = true;
        boolean biometricsSuccessful = true;
        boolean accessGranted = passwordCorrect && biometricsSuccessful;
        System.out.println("Access granted (AND): " + accessGranted);
        
        // Emergency exit: at least one condition must be met
        boolean fireAlarm = false;
        boolean emergencyButtonPressed = true;
        boolean alarmActive = fireAlarm || emergencyButtonPressed;
        System.out.println("Alarm active (OR): " + alarmActive);
        
        // Parity check: XOR for error detection
        int data = 0b1011001;  // 7 bits
        int parityBit = 0;
        for (int i = 0; i < 7; i++) {
            parityBit ^= (data >> i) & 1;  // XOR for parity
        }
        System.out.println("Parity bit: " + parityBit + " (even parity)");
        
        // Multiplexer selection
        int select = 2;  // 0, 1, 2, or 3
        boolean select0 = (select & 1) == 0 && (select & 2) == 0;
        boolean select1 = (select & 1) == 1 && (select & 2) == 0;
        boolean select2 = (select & 1) == 0 && (select & 2) == 2;
        boolean select3 = (select & 1) == 1 && (select & 2) == 2;
        
        System.out.println("Multiplexer select " + select + ":");
        System.out.println("  Output 0: " + select0);
        System.out.println("  Output 1: " + select1);
        System.out.println("  Output 2: " + select2);
        System.out.println("  Output 3: " + select3);
    }
}

2. Logic Gates as Circuits (Python)

class LogicGate:
    """Implementation of logic gates"""
    
    @staticmethod
    def and_gate(a, b):
        """AND gate"""
        return a and b
    
    @staticmethod
    def or_gate(a, b):
        """OR gate"""
        return a or b
    
    @staticmethod
    def not_gate(a):
        """NOT gate (inverter)"""
        return not a
    
    @staticmethod
    def nand_gate(a, b):
        """NAND gate"""
        return not (a and b)
    
    @staticmethod
    def nor_gate(a, b):
        """NOR gate"""
        return not (a or b)
    
    @staticmethod
    def xor_gate(a, b):
        """XOR gate"""
        return a != b
    
    @staticmethod
    def xnor_gate(a, b):
        """XNOR gate (equivalence)"""
        return a == b

class CircuitDesign:
    """Design of digital circuits"""
    
    @staticmethod
    def half_adder(a, b):
        """Half adder: sum and carry"""
        sum_out = LogicGate.xor_gate(a, b)
        carry = LogicGate.and_gate(a, b)
        return sum_out, carry
    
    @staticmethod
    def full_adder(a, b, c_in):
        """Full adder: with input carry"""
        # First half adder
        sum_1, carry_1 = CircuitDesign.half_adder(a, b)
        
        # Second half adder
        sum_2, carry_2 = CircuitDesign.half_adder(sum_1, c_in)
        
        # Final carry out
        carry_out = LogicGate.or_gate(carry_1, carry_2)
        
        return sum_2, carry_out
    
    @staticmethod
    def multiplexer(a, b, s):
        """2-to-1 multiplexer"""
        # When s=0, output=a; when s=1, output=b
        not_s = LogicGate.not_gate(s)
        output_a = LogicGate.and_gate(a, not_s)
        output_b = LogicGate.and_gate(b, s)
        return LogicGate.or_gate(output_a, output_b)
    
    @staticmethod
    def demultiplexer(d, s):
        """1-to-2 demultiplexer"""
        # When s=0, y0=d, y1=0; when s=1, y0=0, y1=d
        not_s = LogicGate.not_gate(s)
        y0 = LogicGate.and_gate(d, not_s)
        y1 = LogicGate.and_gate(d, s)
        return y0, y1
    
    @staticmethod
    def rs_flipflop(r, s, q_old):
        """RS flip-flop (asynchronous)"""
        # Q_new = (S OR (NOT R AND Q_old))
        not_r = LogicGate.not_gate(r)
        temp = LogicGate.and_gate(not_r, q_old)
        q_new = LogicGate.or_gate(s, temp)
        q_bar_new = LogicGate.not_gate(q_new)
        return q_new, q_bar_new

def print_truth_table(gate_name, gate_function):
    """Prints truth table for a gate"""
    print(f"\n=== {gate_name} ===")
    print("A B | Output")
    print("---+--------")
    
    for a in [False, True]:
        for b in [False, True]:
            result = gate_function(a, b)
            print(f"{int(a)} {int(b)} |   {int(result)}")

def main():
    """Main program with demonstrations"""
    
    # Truth tables
    print_truth_table("AND", LogicGate.and_gate)
    print_truth_table("OR", LogicGate.or_gate)
    print_truth_table("NAND", LogicGate.nand_gate)
    print_truth_table("NOR", LogicGate.nor_gate)
    print_truth_table("XOR", LogicGate.xor_gate)
    print_truth_table("XNOR", LogicGate.xnor_gate)
    
    # Circuit design demonstrations
    print("\n=== Half Adder ===")
    for a in [False, True]:
        for b in [False, True]:
            sum_out, carry = CircuitDesign.half_adder(a, b)
            print(f"{int(a)} + {int(b)} = Sum: {int(sum_out)}, Carry: {int(carry)}")
    
    print("\n=== Full Adder ===")
    for a in [False, True]:
        for b in [False, True]:
            for c_in in [False, True]:
                sum_out, carry = CircuitDesign.full_adder(a, b, c_in)
                print(f"{int(c_in)}{int(a)} + {int(b)} = Sum: {int(sum_out)}, Carry: {int(carry)}")
    
    print("\n=== Multiplexer ===")
    for s in [False, True]:
        output = CircuitDesign.multiplexer(True, False, s)
        print(f"Select {int(s)}: Output = {int(output)}")
    
    print("\n=== RS Flip-Flop ===")
    q_old = False
    print(f"Q_old = {int(q_old)}")
    
    # Set
    q_new, q_bar_new = CircuitDesign.rs_flipflop(False, True, q_old)
    print(f"S=1, R=0: Q={int(q_new)}, Q_bar={int(q_bar_new)}")
    
    # Hold
    q_new, q_bar_new = CircuitDesign.rs_flipflop(False, False, q_new)
    print(f"S=0, R=0: Q={int(q_new)}, Q_bar={int(q_bar_new)}")
    
    # Reset
    q_new, q_bar_new = CircuitDesign.rs_flipflop(True, False, q_new)
    print(f"S=0, R=1: Q={int(q_new)}, Q_bar={int(q_bar_new)}")

if __name__ == "__main__":
    main()

3. Boolean Algebra with Bit Operations (C++)

#include <iostream>
#include <bitset>
#include <string>

class BooleanAlgebraCPP {
public:
    // Bit operations for logic gates
    static bool and_gate(bool a, bool b) {
        return a & b;
    }
    
    static bool or_gate(bool a, bool b) {
        return a | b;
    }
    
    static bool not_gate(bool a) {
        return !a;
    }
    
    static bool nand_gate(bool a, bool b) {
        return !(a & b);
    }
    
    static bool nor_gate(bool a, bool b) {
        return !(a | b);
    }
    
    static bool xor_gate(bool a, bool b) {
        return a ^ b;
    }
    
    // Boolean functions with multiple inputs
    static bool and_n(bool inputs[], int n) {
        bool result = true;
        for (int i = 0; i < n; i++) {
            result &= inputs[i];
        }
        return result;
    }
    
    static bool or_n(bool inputs[], int n) {
        bool result = false;
        for (int i = 0; i < n; i++) {
            result |= inputs[i];
        }
        return result;
    }
    
    // Parity check
    static bool even_parity(unsigned int value) {
        bool parity = false;
        while (value > 0) {
            parity ^= (value & 1);
            value >>= 1;
        }
        return !parity;  // Even parity
    }
    
    // Gray code conversion
    static unsigned int decimal_to_gray(unsigned int decimal) {
        return decimal ^ (decimal >> 1);
    }
    
    static unsigned int gray_to_decimal(unsigned int gray) {
        unsigned int decimal = 0;
        while (gray > 0) {
            decimal ^= gray;
            gray >>= 1;
        }
        return decimal;
    }
    
    // Karnaugh diagram helper
    static void print_karnaugh_diagram() {
        std::cout << "\n=== Karnaugh Diagram (2 Variables) ===\n";
        std::cout << "  AB\\CD  00  01  11  10\n";
        std::cout << "  -----------------------\n";
        
        // Example function: F = A'B + AB'
        for (int a = 0; a <= 1; a++) {
            for (int b = 0; b <= 1; b++) {
                std::string ab = std::to_string(a) + std::to_string(b);
                std::cout << "    " << ab << "   ";
                
                for (int c = 0; c <= 1; c++) {
                    for (int d = 0; d <= 1; d++) {
                        // F = A'B + AB'
                        bool f = (!a && b) || (a && !b);
                        std::cout << " " << f << "  ";
                    }
                }
                std::cout << "\n";
                break;  // Only one row for 2 variables
            }
        }
    }
};

int main() {
    std::cout << "=== Boolean Algebra in C++ ===\n";
    
    // Basic operations
    bool a = true;
    bool b = false;
    
    std::cout << "a = " << a << ", b = " << b << "\n";
    std::cout << "a AND b = " << BooleanAlgebraCPP::and_gate(a, b) << "\n";
    std::cout << "a OR b = " << BooleanAlgebraCPP::or_gate(a, b) << "\n";
    std::cout << "NOT a = " << BooleanAlgebraCPP::not_gate(a) << "\n";
    std::cout << "a XOR b = " << BooleanAlgebraCPP::xor_gate(a, b) << "\n";
    
    // Multiple inputs
    std::cout << "\n=== Multiple Inputs ===\n";
    bool inputs[4] = {true, false, true, false};
    std::cout << "AND of all inputs: " << BooleanAlgebraCPP::and_n(inputs, 4) << "\n";
    std::cout << "OR of all inputs: " << BooleanAlgebraCPP::or_n(inputs, 4) << "\n";
    
    // Parity check
    std::cout << "\n=== Parity Check ===\n";
    unsigned int values[] = {0b1011001, 0b1101101, 0b1110000};
    for (unsigned int value : values) {
        std::cout << "Value: " << std::bitset<7>(value) 
                  << ", even parity: " << BooleanAlgebraCPP::even_parity(value) << "\n";
    }
    
    // Gray code
    std::cout << "\n=== Gray Code Conversion ===\n";
    for (unsigned int i = 0; i < 8; i++) {
        unsigned int gray = BooleanAlgebraCPP::decimal_to_gray(i);
        unsigned int back = BooleanAlgebraCPP::gray_to_decimal(gray);
        std::cout << i << " -> " << std::bitset<3>(gray) 
                  << " -> " << back << "\n";
    }
    
    // Bit manipulation
    std::cout << "\n=== Bit Manipulation ===\n";
    unsigned int register_value = 0b10101010;
    
    std::cout << "Original: " << std::bitset<8>(register_value) << "\n";
    
    // Set bit
    unsigned int bit_set = register_value | (1 << 3);
    std::cout << "Set bit 3: " << std::bitset<8>(bit_set) << "\n";
    
    // Clear bit
    unsigned int bit_cleared = register_value & ~(1 << 5);
    std::cout << "Clear bit 5: " << std::bitset<8>(bit_cleared) << "\n";
    
    // Toggle bit
    unsigned int bit_toggled = register_value ^ (1 << 1);
    std::cout << "Toggle bit 1: " << std::bitset<8>(bit_toggled) << "\n";
    
    // Check bit
    bool bit_4_set = (register_value & (1 << 4)) != 0;
    std::cout << "Bit 4 set: " << bit_4_set << "\n";
    
    // Karnaugh diagram
    BooleanAlgebraCPP::print_karnaugh_diagram();
    
    return 0;
}

4. Boolean Algebra and Simplification

public class Schaltalgebra {
    
    // Boolesche Ausdrücke als Methoden
    public static boolean ausdruck1(boolean a, boolean b, boolean c) {
        // Original: (A AND B) OR (A AND C)
        return (a && b) || (a && c);
    }
    
    public static boolean ausdruck1Vereinfacht(boolean a, boolean b, boolean c) {
        // Simplified: A AND (B OR C)  (Distributive Law)
        return a && (b || c);
    }
    
    public static boolean ausdruck2(boolean a, boolean b, boolean c) {
        // Original: (A OR B) AND (A OR C) AND (NOT B OR C)
        return (a || b) && (a || c) && (!b || c);
    }
    
    public static boolean ausdruck2Vereinfacht(boolean a, boolean b, boolean c) {
        // Simplified: A AND (NOT B OR C) OR (B AND C)
        return (a && (!b || c)) || (b && c);
    }
    
    public static boolean ausdruck3(boolean a, boolean b) {
        // Original: (A AND NOT B) OR (NOT A AND B)
        return (a && !b) || (!a && b);
    }
    
    public static boolean ausdruck3Vereinfacht(boolean a, boolean b) {
        // Simplified: A XOR B
        return a ^ b;
    }
    
    // Wahrheitstabellen für Vergleich
    public static void vergleicheAusdruecke() {
        System.out.println("=== Expression Comparison ===");
        System.out.println("A B C | Orig1 | Simp1 | Orig2 | Simp2 | Orig3 | Simp3");
        System.out.println("-------+-------+-------+-------+-------+-------+-------");
        
        for (boolean a : new boolean[]{false, true}) {
            for (boolean b : new boolean[]{false, true}) {
                for (boolean c : new boolean[]{false, true}) {
                    boolean orig1 = ausdruck1(a, b, c);
                    boolean simp1 = ausdruck1Vereinfacht(a, b, c);
                    boolean orig2 = ausdruck2(a, b, c);
                    boolean simp2 = ausdruck2Vereinfacht(a, b, c);
                    boolean orig3 = ausdruck3(a, b);
                    boolean simp3 = ausdruck3Vereinfacht(a, b);
                    
                    System.out.printf("%d %d %d |  %d    |  %d    |  %d    |  %d    |  %d    |  %d%n",
                                    a?1:0, b?1:0, c?1:0,
                                    orig1?1:0, simp1?1:0,
                                    orig2?1:0, simp2?1:0,
                                    orig3?1:0, simp3?1:0);
                }
            }
        }
    }
    
    // NAND-NOR Implementierung (universelle Gatter)
    public static boolean andMitNand(boolean a, boolean b) {
        // AND = NOT(NAND(A,B))
        return !(!(a && b));
    }
    
    public static boolean orMitNand(boolean a, boolean b) {
        // OR = NOT(NAND(NOT(A), NOT(B)))
        return !(!a && !b);
    }
    
    public static boolean notMitNand(boolean a) {
        // NOT = NAND(A,A)
        return !(a && a);
    }
    
    public static boolean xorMitNand(boolean a, boolean b) {
        // XOR = NAND(NAND(A,NAND(A,B)), NAND(B,NAND(A,B)))
        boolean nand_ab = !(a && b);
        boolean nand_a_nandab = !(a && nand_ab);
        boolean nand_b_nandab = !(b && nand_ab);
        return !(nand_a_nandab && nand_b_nandab);
    }
    
    // NOR Implementierung
    public static boolean andMitNor(boolean a, boolean b) {
        // AND = NOR(NOR(A,A), NOR(B,B))
        return !(!a || !b);
    }
    
    public static boolean orMitNor(boolean a, boolean b) {
        // OR = NOT(NOR(A,B))
        return !(a || b);
    }
    
    public static boolean notMitNor(boolean a) {
        // NOT = NOR(A,A)
        return !(a || a);
    }
    
    public static void universaleGatterDemo() {
        System.out.println("\n=== Universal Gates Demonstration ===");
        
        boolean a = true;
        boolean b = false;
        
        System.out.println("a = " + a + ", b = " + b);
        
        // NAND-Implementierungen
        System.out.println("\nNAND Implementations:");
        System.out.println("AND with NAND: " + andMitNand(a, b));
        System.out.println("OR with NAND: " + orMitNand(a, b));
        System.out.println("NOT with NAND: " + notMitNand(a));
        System.out.println("XOR with NAND: " + xorMitNand(a, b));
        
        // NOR-Implementierungen
        System.out.println("\nNOR Implementations:");
        System.out.println("AND with NOR: " + andMitNor(a, b));
        System.out.println("OR with NOR: " + orMitNor(a, b));
        System.out.println("NOT with NOR: " + notMitNor(a));
    }
    
    public static void main(String[] args) {
        vergleicheAusdruecke();
        universaleGatterDemo();
        
        // Komplexere Schaltung: 4-zu-1 Multiplexer
        multiplexerDemo();
    }
    
    private static void multiplexerDemo() {
        System.out.println("\n=== 4-to-1 Multiplexer ===");
        
        boolean d0 = true, d1 = false, d2 = true, d3 = false;
        boolean s0 = true, s1 = false;  // Select lines
        
        // Multiplexer logic
        boolean y = (d0 && !s0 && !s1) || 
                   (d1 && s0 && !s1) || 
                   (d2 && !s0 && s1) || 
                   (d3 && s0 && s1);
        
        System.out.println("Data: D0=" + d0 + ", D1=" + d1 + ", D2=" + d2 + ", D3=" + d3);
        System.out.println("Select: S0=" + s0 + ", S1=" + s1);
        System.out.println("Output Y: " + y);
    }
}

Truth Table Overview

Basic Gates (2 Inputs)

A	B	AND	OR	NAND	NOR	XOR	XNOR
0	0	0	0	1	1	0	1
0	1	0	1	1	0	1	0
1	0	0	1	1	0	1	0
1	1	1	1	0	0	0	1

NOT Gate (1 Input)

A	NOT
0	1
1	0

Boolean Algebra Laws

Commutative Laws

A ∧ B = B ∧ A
A ∨ B = B ∨ A

Associative Laws

(A ∧ B) ∧ C = A ∧ (B ∧ C)
(A ∨ B) ∨ C = A ∨ (B ∨ C)

Distributive Laws

A ∧ (B ∨ C) = (A ∧ B) ∨ (A ∧ C)
A ∨ (B ∧ C) = (A ∨ B) ∧ (A ∨ C)

De Morgan’s Laws

¬(A ∧ B) = ¬A ∨ ¬B
¬(A ∨ B) = ¬A ∧ ¬B

Idempotent Laws

A ∧ A = A
A ∨ A = A

Null and Identity Laws

A ∧ 0 = 0
A ∨ 1 = 1
A ∧ 1 = A
A ∨ 0 = A

Complement Laws

A ∧ ¬A = 0
A ∨ ¬A = 1
¬(¬A) = A

Logic Gate Symbols

ANSI/IEEE Symbols

AND: D-shaped gate
OR: Curved gate
NOT: Triangle with circle
NAND: AND with circle
NOR: OR with circle
XOR: OR with additional line

DIN Symbols (European)

AND: Rectangle with &
OR: Rectangle with ≥1
NOT: Rectangle with 1
NAND: Rectangle with &
NOR: Rectangle with ≥1
XOR: Rectangle with =1

Combinational Circuits

Adders

Half Adder: 2 bits → sum + carry
Full Adder: 3 bits → sum + carry
Ripple-Carry Adder: Multiple full adders chained

Multiplexers/Demultiplexers

Multiplexer: Selector from multiple inputs
Demultiplexer: Distributor to multiple outputs
Applications: Data buses, addressing

Encoders/Decoders

Encoder: Multiple inputs → binary code
Decoder: Binary code → multiple outputs
Applications: Keyboards, 7-segment displays

Advantages and Disadvantages

Advantages of Boolean Algebra

Simplicity: Only two states
Reliability: Robust digital circuits
Simplification: Complex logic can be minimized
Automation: Well-suited for computer design

Disadvantages

Abstraction: Not intuitive for complex problems
Limitation: Binary logic only
Complexity: Large circuits become unwieldy

Common Exam Questions

Create a truth table for XOR! XOR is true when the inputs differ.
What do De Morgan’s Laws state? ¬(A ∧ B) = ¬A ∨ ¬B and ¬(A ∨ B) = ¬A ∧ ¬B
Why are NAND and NOR universal gates? All other logical functions can be implemented using only NAND or NOR.
What is the difference between a half adder and a full adder? A half adder has 2 inputs, while a full adder has 3 inputs (including carry-in).

Täglicher Artikel